Gitiles
Code Review Sign In
192.168.1.100 / T108 / c8c95bbfb63cd52cb22cbf538f33b9fc96a99ee3 / . / marvell / lte-telephony / apps / atcmd_server_ss / src / teldev.c
blob: 0337fd3cc938b32edfdd8a26cdfc19ce1d75e03e [file] [log] [blame]
/******************************************************************************
*(C) Copyright 2007 Marvell International Ltd.
* All Rights Reserved
******************************************************************************
* Filename: teldev.c
*
* Description: Process dev related AT commands
*
* History:
* Jan 17, 2008 - Creation of file
* Oct 17, 2008 - Qiang XU, Optimization
*
******************************************************************************/
/******************************************************************************
* Include files
******************************************************************************/
#include <limits.h>
#include "teldev.h"
#include "teldef.h"
#include "ci_api_types.h"
#include "ci_api.h"
#include "ci_dev.h"
#include "telmsg.h"
#include "telatci.h"
#include "telconfig.h"
#include "telatparamdef.h"
#include "telutl.h"
#include "dev_api.h"
#include "utilities.h"
#include "telcontroller.h"
#include "eeh_assert_notify.h"
#include "cploader.h"
#include "cc_api.h"
#include <cutils/properties.h>
#include "utlMalloc.h"
#include <stdlib.h>
#include <string.h>
#include "utlAtParser.h"
#include <stdio.h>
#include "atcmdsvr_ubus.h"
#include <unistd.h>
#include <sys/wait.h>
#ifdef MBTK_AT_SUPPORT
#include "mbtk_device_info.h"
#endif
extern char * getAsrFlagPath(void);
extern unsigned char *cp_set_ddr_flag(int offset, unsigned int value);
char internalRevisionId[MAX_INTERNALREVISION_ID_LENGTH + 1] = "unknown";
char buildTimeStr[MAX_BUILDTIME_STR_LENGTH + 1] = "unknown";
#define TEL_MODE_SZ 15 /* = max(telMode[]) = sizeof("PRODUCT_NO_GUI")=14+1 */
char gTelMode[TEL_MODE_SZ] = "NORMAL";
BOOL g_IsCgedOn = FALSE;
BOOL g_IsCellInfoPeriodic = FALSE;
extern int gNumofAT;
int gPowerind = 0;
int gPowerindTmp = 0;
extern CiServiceHandle gAtciSvgHandle[CI_SG_NUMIDS + 1];
UINT8 gNullPrxysetFlag = 0;
/************************************************************************************
*
* Dev related global variables and structure
*
*************************************************************************************/
extern CiDevEngModeReportOption gEngModeRepOpt;
extern CiDevEngModeReportOption gEngModeRepOpt_1;
extern int gCurrTimeVal;
extern int gCurrTimeVal_1;
extern utlAtParser_P aParser_p[];
extern utlAtProxyCommand_P atProxyReq;
extern utlAtProxyCommand_P atProxyInd;
extern TelAtParserID gProxyChannelId; //the current channel ID for proxy
extern TelAtParserID gOrigParserId;
extern UINT32 gCurrentProxyTrsXid;
extern BOOL gCurrentPrxyFirstPhase;
extern const char * VENDOR_SW_VERSION;
extern pthread_mutex_t gProxyAccessLock;
extern CiReturnCode Dev_L1Debug(UINT32 atHandle, CHAR *data, UINT16 length);
extern BOOL ims_sms_data_invalid_report_error;
extern BOOL gImsRegState;
extern BOOL gImsRegState_1;
extern TelMsgDataMode gCurrentSmsDataMode;
/************************************************************************************
*
* DEV related AT commands
*
*************************************************************************************/
/*
#define isxdigit(c) (('0' <= (c) && (c) <= '9') \
|| ('a' <= (c) && (c) <= 'f') \
|| ('A' <= (c) && (c) <= 'F'))
*/
/************************************************************************************
* F@: ciFuncSet - GLOBAL API for GCF AT+CFUN -command
*
*/
RETURNCODE_T ciFuncSet( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciFuncSet, "ciFuncSet: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_GET_CMD: /* AT+CFUN? */
{
ret = DEV_GetFunc(atHandle, FALSE);
break;
}
case TEL_EXT_TEST_CMD: /* AT+CFUN=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,(char *)"+CFUN: (0,1,3,4,5,6),(0-1)\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT+CFUN= */
{
INT32 funcVal, resetVal;
/* Extract the arguments starting with the functionality. */
if ( (getExtValue(parameter_values_p, 0, &funcVal, TEL_AT_CFUN_0_FUN_VAL_MIN, TEL_AT_CFUN_0_FUN_VAL_MAX, TEL_AT_CFUN_0_FUN_VAL_DEFAULT) == TRUE)
&& ((funcVal <= ATCI_CFUN_OP_FULL_FUNC) || (funcVal == ATCI_CFUN_OP_DISABLE_RF_RX) || (funcVal == ATCI_CFUN_OP_DISABLE_RF_RXTX)
|| (funcVal == ATCI_PLUS_CFUN_OP_DISABLE_SIM) || (funcVal == ATCI_PLUS_CFUN_OP_FULL_SECONDARY_RX_OFF)))
{
if(funcVal == ATCI_PLUS_CFUN_OP_DISABLE_SIM)
funcVal = ATCI_CFUN_OP_DISABLE_SIM;
else if(funcVal == ATCI_PLUS_CFUN_OP_FULL_SECONDARY_RX_OFF)
funcVal = ATCI_CFUN_OP_FULL_SECONDARY_RX_OFF;
/* Get the reset flag; default value shall be 0 */
if ( getExtValue( parameter_values_p, 1, &resetVal, TEL_AT_CFUN_1_RST_VAL_MIN, TEL_AT_CFUN_1_RST_VAL_MAX, TEL_AT_CFUN_1_RST_VAL_DEFAULT ) == TRUE )
{
ret = DEV_SetFunc(atHandle, funcVal, resetVal, set_func_req_plus_cfun, 0, 0);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
}
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
}
break;
}
case TEL_EXT_ACTION_CMD: /* AT+CFUN */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciFuncSet - GLOBAL API for GCF AT*CFUN -command
*
*/
RETURNCODE_T ciFuncCpConfig( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
INT32 IsCommFeatureConfig;
INT32 CommFeatureConfig;
*xid_p = atHandle;
//DBGMSG(ciFuncCpConfig, "ciFuncCpConfig: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_GET_CMD: /* AT*CFUN? */
{
ret = DEV_GetFunc(atHandle, TRUE);
break;
}
case TEL_EXT_TEST_CMD: /* AT*CFUN=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CFUN: (0,1,4,5,6,9),(0-1),(0,1),(0-63)\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT*CFUN= */
{
BOOL cmdValid = FALSE;
INT32 funcVal, resetVal;
/* Extract the arguments starting with the functionality. */
if ( (getExtValue(parameter_values_p, 0, &funcVal, TEL_AT_CFUN_0_FUN_VAL_MIN, TEL_AT_CFUN_0_FUN_VAL_MAX, TEL_AT_CFUN_0_FUN_VAL_DEFAULT) == TRUE)
&& ((funcVal <= ATCI_CFUN_OP_FULL_FUNC) || (funcVal == ATCI_CFUN_OP_DISABLE_RF_RX) || (funcVal == ATCI_CFUN_OP_DISABLE_RF_RXTX)
|| (funcVal == ATCI_CFUN_OP_UPDATE_NVM_MIN_FUNC) || (funcVal == ATCI_CFUN_OP_UPDATE_NVM_FULL_FUNC) || (funcVal == ATCI_CFUN_OP_UPDATE_NVM_DISABLE_RF_RXTX)))
{
/* Get the reset flag; default value shall be 0 */
if ( getExtValue( parameter_values_p, 1, &resetVal, TEL_AT_CFUN_1_RST_VAL_MIN, TEL_AT_CFUN_1_RST_VAL_MAX, TEL_AT_CFUN_1_RST_VAL_DEFAULT ) == TRUE )
{
if ( getExtValue( parameter_values_p, 2, &IsCommFeatureConfig, TEL_AT_CFUN_2_EN_CONFIG_VAL_MIN, TEL_AT_CFUN_2_EN_CONFIG_VAL_MAX, TEL_AT_CFUN_2_EN_CONFIG_VAL_DEFAULT ) == TRUE )
{
if ( getExtValue( parameter_values_p, 3, &CommFeatureConfig, TEL_AT_CFUN_3_CONFIG_VAL_MIN, TEL_AT_CFUN_3_CONFIG_VAL_MAX, TEL_AT_CFUN_3_CONFIG_VAL_DEFAULT ) == TRUE )
{
cmdValid = TRUE;
ret = DEV_SetFunc(atHandle, funcVal, resetVal, set_func_req_star_cfun, IsCommFeatureConfig, CommFeatureConfig);
}
}
}
}
if(!cmdValid)
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_ACTION_CMD: /* AT*CFUN */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
/ * F@: ciDevStatus - GLOBAL API for GCF AT+CPAS-command
*
*/
RETURNCODE_T ciDevStatus( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciDevStatus, "ciDevStatus: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_TEST_CMD: /* AT+CPAS=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CPAS: (0,1,2,3,4,5,6)\r\n");
break;
}
case TEL_EXT_ACTION_CMD: /* AT+CPAS */
{
/*
** Retrieve the device status from the global variable.
** This variable is updated everytime the CI_DEV_PRIM_STATUS_IND
** is received. The result originates from the last time
** the indication was received.
*/
ret = DEV_GetDevStatus(atHandle);
break;
}
case TEL_EXT_GET_CMD: /* AT+CPAS? */
case TEL_EXT_SET_CMD: /* AT+CPAS= */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
/ * F@: ciCGED - GLOBAL API for AT+CGED-command
*
*/
RETURNCODE_T ciCGED( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciCGED, "ciCGED: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_TEST_CMD: /* AT+CGED=? */
{
ATRESP( atHandle, 0, 0, (char *)"AT+CGED=0 :Export the EM information once for each request.");
ATRESP( atHandle, 0, 0, (char *)"AT+CGED=1,<interval> :Export the EM information periodically in every interval seconds.");
ATRESP( atHandle, 0, 0, (char *)"AT+CGED=2 :Disable Engineering mode, stop output Engineering mode information.");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_SUPPRESS, 0, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT+CGED=*/
{
INT32 modeVal, timeVal;
if ( getExtValue(parameter_values_p, 0, &modeVal, TEL_AT_CGED_0_MODE_VAL_MIN, TEL_AT_CGED_0_MODE_VAL_MAX, TEL_AT_CGED_0_MODE_VAL_DEFAULT) == TRUE )
{
if(getExtValue( parameter_values_p, 1, &timeVal, TEL_AT_CGED_1_INTERVAL_VAL_MIN, TEL_AT_CGED_1_INTERVAL_VAL_MAX, TEL_AT_CGED_1_INTERVAL_VAL_DEFAULT) == TRUE)
ret = DEV_SetEngineModeReportOption(atHandle, modeVal, timeVal);
}
break;
}
case TEL_EXT_GET_CMD: /* AT+CGED? */
case TEL_EXT_ACTION_CMD: /* AT+CGED */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/* IMEI */
/************************************************************************************
* F@: ciCGSN - GLOBAL API for AT+CGSN/GSN command
*
*/
RETURNCODE_T ciCGSN(
const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciCGSN, "ciCGSN: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_GET_CMD: /* AT+CGSN? */
case TEL_EXT_ACTION_CMD: /* AT+CGSN */
{
ret = DEV_GetSerialNumId(atHandle);
break;
}
case TEL_EXT_TEST_CMD: /* AT+CGSN=? */
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CGSN:\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT+CGSN= */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciSysConfig - GLOBAL API for CMCC AT^SYSCONFIG command
*
*/
RETURNCODE_T ciSysConfig( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
char AtBuf[100];
*xid_p = atHandle;
//DBGMSG(ciSysConfig, "ciSysConfig: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT^SYSCONFIG? */
{
ret = DEV_GetSysConfig(atHandle);
break;
}
case TEL_EXT_SET_CMD: /* AT^SYSCONFIG= */
{
INT32 modeVal, acqorderVal, bandVal=0xffffffff, roamVal, srvdomainVal;
/* Extract the arguments starting with the functionality. */
if( getExtValue(parameter_values_p, 0, &modeVal, 2, 16, 2) == TRUE )
{
/* Get the reset flag; default value shall be 0 */
if( getExtValue( parameter_values_p, 1, &acqorderVal, 0, 3, 2 ) == TRUE )
{
if( getExtValue( parameter_values_p, 2, &roamVal, 0, 2, 1 ) == TRUE )
{
if( getExtValue( parameter_values_p, 3, &srvdomainVal, 0, 4, 2 ) == TRUE )
{
//FixMe: In order to avoid CP to detach, which will cause assert
ret = DEV_SysConfig(atHandle, modeVal, acqorderVal, bandVal,roamVal, srvdomainVal);
}
else
{
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
}
}
else
{
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
}
}
else
{
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
}
}
else
{
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
}
break;
}
default:
{
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#if !defined(ATCMD_1901_CI) && !defined(ATCMD_1903_CI)
RETURNCODE_T ciBAND( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
INT32 NWMode;
UINT32 gsmband, umtsband, eutranhband, eutranlband, ltebandext;
INT32 roamingConfig, srvDomain, bandPriorityFlag;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciBAND, "ciBAND: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT*BAND=? */
{
ret = DEV_GetSupportedBandModeReq(atHandle);
break;
}
case TEL_EXT_GET_CMD: /* AT*BAND? */
{
ret = DEV_GetBandModeReq(atHandle);
break;
}
case TEL_EXT_SET_CMD: /* AT*BAND= */
{
BOOL cmdValid = FALSE;
if ( getExtValue( parameter_values_p, 0, &NWMode, TEL_AT_BAND_NW_MODE_VAL_MIN, TEL_AT_BAND_NW_MODE_VAL_MAX, CI_DEV_NW_MODE_NOT_CHANGE ) == TRUE )
{
if ( getExtUValue( parameter_values_p, 1, &gsmband, TEL_AT_BAND_BAND_VAL_MIN, TEL_AT_BAND_BAND_VAL_MAX, TEL_AT_BAND_BAND_VAL_DEFAULT ) == TRUE )
{
if ( getExtUValue( parameter_values_p, 2, &umtsband, TEL_AT_BAND_BAND_VAL_MIN, TEL_AT_BAND_BAND_VAL_MAX, TEL_AT_BAND_BAND_VAL_DEFAULT ) == TRUE )
{
if ( getExtUValue( parameter_values_p, 3, &eutranhband, TEL_AT_BAND_BAND_VAL_MIN, TEL_AT_BAND_BAND_VAL_MAX, TEL_AT_BAND_BAND_VAL_DEFAULT ) == TRUE )
{
if ( getExtUValue( parameter_values_p, 4, &eutranlband, TEL_AT_BAND_BAND_VAL_MIN, TEL_AT_BAND_BAND_VAL_MAX, TEL_AT_BAND_BAND_VAL_DEFAULT ) == TRUE )
{
if ( getExtValue( parameter_values_p, 5, &roamingConfig, TEL_AT_BAND_ROAMING_CONFIG_VAL_MIN, TEL_AT_BAND_ROAMING_CONFIG_VAL_MAX, TEL_AT_BAND_ROAMING_CONFIG_VAL_DEFAULT ) == TRUE )
{
if ( getExtValue( parameter_values_p, 6, &srvDomain, TEL_AT_BAND_SRV_DOMAIN_VAL_MIN, TEL_AT_BAND_SRV_DOMAIN_VAL_MAX, TEL_AT_BAND_SRV_DOMAIN_VAL_DEFAULT ) == TRUE )
{
if(getExtValue(parameter_values_p, 7, &bandPriorityFlag, TEL_AT_BAND_BAND_PRIORITY_VAL_MIN, TEL_AT_BAND_BAND_PRIORITY_VAL_MAX, TEL_AT_BAND_BAND_PRIORITY_VAL_DEFAULT) == TRUE)
{
if(getExtUValue(parameter_values_p, 8, &ltebandext, TEL_AT_BAND_BAND_VAL_MIN, TEL_AT_BAND_BAND_VAL_MAX, TEL_AT_BAND_BAND_VAL_DEFAULT) == TRUE)
{
cmdValid = TRUE;
switch (NWMode)
{
case DEV_NW_GSM_MODE: //GSM network
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_GSM, CI_DEV_NW_GSM, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, 0, 0, ltebandext);
break;
}
case DEV_NW_UMTS_MODE: //UMTS network
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_UMTS, CI_DEV_NW_UMTS, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, 0, 0, ltebandext);
break;
}
case DEV_NW_DUAL_GSM_UMTS_MODE: //Dual mode(auto)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_GSM_UMTS, CI_DEV_NW_GSM_UMTS, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, 0, 0, ltebandext);
break;
}
case DEV_NW_DUAL_GSM_UMTS_MODE_GSM: //Dual mode(GSM preferred)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_GSM_UMTS, CI_DEV_NW_GSM, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, 0, 0, ltebandext);
break;
}
case DEV_NW_DUAL_GSM_UMTS_MODE_UMTS: //Dual mode(UMTS preferred)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_GSM_UMTS, CI_DEV_NW_UMTS, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, 0, 0, ltebandext);
break;
}
case DEV_NW_LTE_MODE: //LTE mode
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_LTE, CI_DEV_NW_LTE, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 0, ltebandext);
break;
}
case DEV_NW_DUAL_GSM_LTE_MODE: //GSM_LTE(auto)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_GSM_LTE, CI_DEV_NW_GSM_LTE, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 0, ltebandext);
break;
}
case DEV_NW_DUAL_GSM_LTE_MODE_GSM: //GSM_LTE(GSM preferred)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_GSM_LTE, CI_DEV_NW_GSM, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 0, ltebandext);
break;
}
case DEV_NW_DUAL_GSM_LTE_MODE_LTE: //GSM_LTE(LTE preferred)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_GSM_LTE, CI_DEV_NW_LTE, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 0, ltebandext);
break;
}
case DEV_NW_DUAL_UMTS_LTE_MODE: //UMTS_LTE(auto)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_UMTS_LTE, CI_DEV_NW_UMTS_LTE, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 0, ltebandext);
break;
}
case DEV_NW_DUAL_UMTS_LTE_MODE_UMTS: //UMTS_LTE(UMTS preferred)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_UMTS_LTE, CI_DEV_NW_UMTS, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 0, ltebandext);
break;
}
case DEV_NW_DUAL_UMTS_LTE_MODE_LTE: //UMTS_LTE(LTE preferred)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_UMTS_LTE, CI_DEV_NW_LTE, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 0, ltebandext);
break;
}
case DEV_NW_TRIP_MODE: //Tripple mode(auto)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_GSM_UMTS_LTE, CI_DEV_NW_GSM_UMTS_LTE, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 0, ltebandext);
break;
}
case DEV_NW_TRIP_MODE_GSM: //Tripple mode(GSM preferred)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_GSM_UMTS_LTE, CI_DEV_NW_GSM, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 0, ltebandext);
break;
}
case DEV_NW_TRIP_MODE_UMTS: //Tripple mode(UMTS preferred)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_GSM_UMTS_LTE, CI_DEV_NW_UMTS, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 0, ltebandext);
break;
}
case DEV_NW_TRIP_MODE_LTE: //Tripple mode(LTE preferred)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_GSM_UMTS_LTE, CI_DEV_NW_LTE, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 0, ltebandext);
break;
}
#if defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
case DEV_NW_NR_MODE: //5G only mode
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_NR, CI_DEV_NW_NR, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 0, ltebandext);
break;
}
case DEV_NW_LTE_NR: //dual mode(5G + LTE)
{
ret = DEV_SetBandModeReq(atHandle, CI_DEV_NW_LTE_NR, CI_DEV_NW_LTE_NR, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 0, ltebandext);
break;
}
#endif
case DEV_NW_MODE_NOT_CHANGE:
{
ret = DEV_SetBandModeReqExt(atHandle, CI_DEV_NW_GSM_UMTS_LTE, CI_DEV_NW_UMTS, gsmband, umtsband, eutranhband, eutranlband, roamingConfig, srvDomain, bandPriorityFlag, 1, ltebandext);
break;
}
default:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
}
}
}
}
}
}
}
}
}
if(!cmdValid)
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
case TEL_EXT_ACTION_CMD: /* AT*BAND */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#else
RETURNCODE_T ciBAND( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
RETURNCODE_T rc;
CiReturnCode ret;
UINT32 NWMode;
UINT32 gsmband,umtsband,ltebandh,lteandl;
/* Added by Daniel for CQ00138517, begin */
UINT32 nrFr1BandBitmap[CI_DEV_NR_FR1_BAND_LIST_NUM];
UINT32 nrFr2BandBitmap;
/* Added by Daniel for CQ00138517, end */
UINT32 roamingConfig;
UINT32 srvDomain;
UINT32 bandPriorityFlag;
UINT32 ltebandext;
UINT32 atHandle;
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
rc = INITIAL_RETURN_CODE;
ret = CIRC_FAIL;
atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//INFOMSG(ciBAND, "ciBAND: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT*BAND=? */
{
ret = DEV_GetSupportedBandModeReq(atHandle);
break;
}
case TEL_EXT_GET_CMD: /* AT*BAND? */
{
ret = DEV_GetBandModeReq(atHandle);
break;
}
case TEL_EXT_SET_CMD: /* AT*BAND= */
{
if(getExtValue(parameter_values_p, 0, &NWMode, TEL_AT_BAND_NW_MODE_VAL_MIN, TEL_AT_BAND_NW_MODE_VAL_MAX, TEL_AT_BAND_NW_MODE_VAL_DEFAULT ) == TRUE)
{
if(getExtUValue(parameter_values_p, 1, &gsmband, TEL_AT_BAND_BAND_VAL_MIN, TEL_AT_BAND_BAND_VAL_MAX, TEL_AT_BAND_BAND_VAL_DEFAULT ) == TRUE)
{
if(getExtUValue(parameter_values_p, 2, &umtsband, TEL_AT_BAND_BAND_VAL_MIN, TEL_AT_BAND_BAND_VAL_MAX, TEL_AT_BAND_BAND_VAL_DEFAULT ) == TRUE)
{
if(getExtUValue(parameter_values_p, 3, &ltebandh, TEL_AT_BAND_BAND_VAL_MIN, TEL_AT_BAND_BAND_VAL_MAX, TEL_AT_BAND_BAND_VAL_DEFAULT ) == TRUE)
{
if(getExtUValue(parameter_values_p, 4, &lteandl, TEL_AT_BAND_BAND_VAL_MIN, TEL_AT_BAND_BAND_VAL_MAX, TEL_AT_BAND_BAND_VAL_DEFAULT ) == TRUE)
{
/* Added by Daniel for CQ00138517, begin */
if(getExtUValue(parameter_values_p, 5, &nrFr1BandBitmap[3], TEL_AT_BAND_NR_BAND_VAL_MIN, TEL_AT_BAND_NR_BAND_VAL_MAX, TEL_AT_BAND_NR_BAND_VAL_DEFAULT ) == TRUE)
{
if(getExtUValue(parameter_values_p, 6, &nrFr1BandBitmap[2], TEL_AT_BAND_NR_BAND_VAL_MIN, TEL_AT_BAND_NR_BAND_VAL_MAX, TEL_AT_BAND_NR_BAND_VAL_DEFAULT ) == TRUE)
{
if(getExtUValue(parameter_values_p, 7, &nrFr1BandBitmap[1], TEL_AT_BAND_NR_BAND_VAL_MIN, TEL_AT_BAND_NR_BAND_VAL_MAX, TEL_AT_BAND_NR_BAND_VAL_DEFAULT ) == TRUE)
{
if(getExtUValue(parameter_values_p, 8, &nrFr1BandBitmap[0], TEL_AT_BAND_NR_BAND_VAL_MIN, TEL_AT_BAND_NR_BAND_VAL_MAX, TEL_AT_BAND_NR_BAND_VAL_DEFAULT ) == TRUE)
{
if(getExtUValue(parameter_values_p, 9, &nrFr2BandBitmap, TEL_AT_BAND_NR_BAND_VAL_MIN, TEL_AT_BAND_NR_BAND_VAL_MAX, TEL_AT_BAND_NR_BAND_VAL_DEFAULT ) == TRUE)
{
/* Added by Daniel for CQ00138517, end */
if(getExtValue(parameter_values_p, 10, &roamingConfig, TEL_AT_BAND_ROAMING_CONFIG_VAL_MIN, TEL_AT_BAND_ROAMING_CONFIG_VAL_MAX, TEL_AT_BAND_ROAMING_CONFIG_VAL_DEFAULT) == TRUE)
{
if(getExtValue(parameter_values_p, 11, &srvDomain, TEL_AT_BAND_SRV_DOMAIN_VAL_MIN, TEL_AT_BAND_SRV_DOMAIN_VAL_MAX, TEL_AT_BAND_SRV_DOMAIN_VAL_DEFAULT) == TRUE)
{
if(getExtValue(parameter_values_p, 12, &bandPriorityFlag, TEL_AT_BAND_BAND_PRIORITY_VAL_MIN, TEL_AT_BAND_BAND_PRIORITY_VAL_MAX, TEL_AT_BAND_BAND_PRIORITY_VAL_DEFAULT) == TRUE)
{
if(getExtUValue(parameter_values_p, 13, &ltebandext, TEL_AT_BAND_BAND_VAL_MIN, TEL_AT_BAND_BAND_VAL_MAX, TEL_AT_BAND_BAND_VAL_DEFAULT) == TRUE)
{
UINT8 networkMode = CI_DEV_NUM_NW_MODES;
UINT8 preferredMode = CI_DEV_NUM_NW_MODES;
UINT8 bSetBand = TRUE;
switch(NWMode)
{
case DEV_NW_GSM_MODE: //GSM network
{
networkMode = CI_DEV_NW_GSM;
preferredMode = CI_DEV_NW_GSM;
bandPriorityFlag = 0;
break;
}
case DEV_NW_UMTS_MODE: //UMTS network
{
networkMode = CI_DEV_NW_UMTS;
preferredMode = CI_DEV_NW_UMTS;
bandPriorityFlag = 0;
break;
}
case DEV_NW_DUAL_GSM_UMTS_MODE: //Dual mode (auto)
{
networkMode = CI_DEV_NW_GSM_UMTS;
preferredMode = CI_DEV_NW_GSM_UMTS;
bandPriorityFlag = 0;
break;
}
case DEV_NW_DUAL_GSM_UMTS_MODE_GSM: //Dual mode(GSM preferred)
{
networkMode = CI_DEV_NW_GSM_UMTS;
preferredMode = CI_DEV_NW_GSM;
break;
}
case DEV_NW_DUAL_GSM_UMTS_MODE_UMTS: //Dual mode(UMTS preferred)
{
networkMode = CI_DEV_NW_GSM_UMTS;
preferredMode = CI_DEV_NW_UMTS;
break;
}
case DEV_NW_LTE_MODE: // LTE mode
{
networkMode = CI_DEV_NW_LTE;
preferredMode = CI_DEV_NW_LTE;
break;
}
case DEV_NW_DUAL_GSM_LTE_MODE: //Tripple mode (auto)
{
networkMode = CI_DEV_NW_GSM_LTE;
preferredMode = CI_DEV_NW_GSM_LTE;
break;
}
case DEV_NW_DUAL_GSM_LTE_MODE_GSM: //Tripple mode (GSM preferred)
{
networkMode = CI_DEV_NW_GSM_LTE;
preferredMode = CI_DEV_NW_GSM;
break;
}
case DEV_NW_DUAL_GSM_LTE_MODE_LTE: //Tripple mode (LTE preffered)
{
networkMode = CI_DEV_NW_GSM_LTE;
preferredMode = CI_DEV_NW_LTE;
break;
}
case DEV_NW_DUAL_UMTS_LTE_MODE: //Tripple mode (auto)
{
networkMode = CI_DEV_NW_UMTS_LTE;
preferredMode = CI_DEV_NW_UMTS_LTE;
break;
}
case DEV_NW_DUAL_UMTS_LTE_MODE_UMTS: //Tripple mode (UMTS preferred)
{
networkMode = CI_DEV_NW_UMTS_LTE;
preferredMode = CI_DEV_NW_UMTS;
break;
}
case DEV_NW_DUAL_UMTS_LTE_MODE_LTE: //Tripple mode (LTE preferred)
{
networkMode = CI_DEV_NW_UMTS_LTE;
preferredMode = CI_DEV_NW_LTE;
break;
}
case DEV_NW_TRIP_MODE: //Tripple mode (auto)
{
networkMode = CI_DEV_NW_GSM_UMTS_LTE;
preferredMode = CI_DEV_NW_GSM_UMTS_LTE;
break;
}
case DEV_NW_TRIP_MODE_GSM: //Tripple mode (GSM preferred)
{
networkMode = CI_DEV_NW_GSM_UMTS_LTE;
preferredMode = CI_DEV_NW_GSM;
break;
}
case DEV_NW_TRIP_MODE_UMTS: //Tripple mode (UMTS preferred)
{
networkMode = CI_DEV_NW_GSM_UMTS_LTE;
preferredMode = CI_DEV_NW_UMTS;
break;
}
case DEV_NW_TRIP_MODE_LTE: //Tripple mode (LTE preferred)
{
networkMode = CI_DEV_NW_GSM_UMTS_LTE;
preferredMode = CI_DEV_NW_LTE;
break;
}
case DEV_NW_NR_MODE:
{
networkMode = CI_DEV_NW_NR;
preferredMode = CI_DEV_NW_NR;
break;
}
case DEV_NW_LTE_NR:
{
networkMode = CI_DEV_NW_LTE_NR;
preferredMode = CI_DEV_NW_LTE_NR;
break;
}
case DEV_NW_LTE_NR_MODE_LTE: //LTE_NR(LTE preferred)
{
networkMode = CI_DEV_NW_LTE_NR;
preferredMode = CI_DEV_NW_LTE;
break;
}
case DEV_NW_LTE_NR_MODE_NR: //LTE_NR(NR preferred)
{
networkMode = CI_DEV_NW_LTE_NR;
preferredMode = CI_DEV_NW_NR;
break;
}
case DEV_NW_UMTS_LTE_NR_MODE: //UMTS_LTE_NR
{
networkMode = CI_DEV_NW_UMTS_LTE_NR;
preferredMode = CI_DEV_NW_UMTS_LTE_NR;
break;
}
case DEV_NW_UMTS_LTE_NR_MODE_UMTS: //UMTS_LTE_NR(UMTS preferred)
{
networkMode = CI_DEV_NW_UMTS_LTE_NR;
preferredMode = CI_DEV_NW_UMTS;
break;
}
case DEV_NW_UMTS_LTE_NR_MODE_LTE: //UMTS_LTE_NR(LTE preferred)
{
networkMode = CI_DEV_NW_UMTS_LTE_NR;
preferredMode = CI_DEV_NW_LTE;
break;
}
case DEV_NW_UMTS_LTE_NR_MODE_NR: //UMTS_LTE_NR(NR preferred)
{
networkMode = CI_DEV_NW_UMTS_LTE_NR;
preferredMode = CI_DEV_NW_NR;
break;
}
case DEV_NW_GSM_UMTS_LTE_NR_MODE: //GSM_UMTS_LTE_NR
{
networkMode = CI_DEV_NW_GSM_UMTS_LTE_NR;
preferredMode = CI_DEV_NW_GSM_UMTS_LTE_NR;
break;
}
case DEV_NW_GSM_UMTS_LTE_NR_MODE_GSM: //GSM_UMTS_LTE_NR(GSM preferred)
{
networkMode = CI_DEV_NW_GSM_UMTS_LTE_NR;
preferredMode = CI_DEV_NW_GSM;
break;
}
case DEV_NW_GSM_UMTS_LTE_NR_MODE_UMTS: //GSM_UMTS_LTE_NR(UMTS preferred)
{
networkMode = CI_DEV_NW_GSM_UMTS_LTE_NR;
preferredMode = CI_DEV_NW_UMTS;
break;
}
case DEV_NW_GSM_UMTS_LTE_NR_MODE_LTE: //GSM_UMTS_LTE_NR(LTE preferred)
{
networkMode = CI_DEV_NW_GSM_UMTS_LTE_NR;
preferredMode = CI_DEV_NW_LTE;
break;
}
case DEV_NW_GSM_UMTS_LTE_NR_MODE_NR: //GSM_UMTS_LTE_NR(NR preferred)
{
networkMode = CI_DEV_NW_GSM_UMTS_LTE_NR;
preferredMode = CI_DEV_NW_NR;
break;
}
default:
{
bSetBand = FALSE;
break;
}
}
if (bSetBand == TRUE)
{
ret = DEV_SetBandModeReq(atHandle,
networkMode,
preferredMode,
gsmband,
umtsband,
ltebandh,
lteandl,
&nrFr1BandBitmap[0],
nrFr2BandBitmap,
roamingConfig,
srvDomain,
bandPriorityFlag,
ltebandext);
}
else
{
ret = ATRESP(atHandle,
ATCI_RESULT_CODE_CME_ERROR,
CME_OPERATION_NOT_SUPPORTED,
NULL);
}
}
}
}
}
/* Added by Daniel for CQ00138517, begin */
}
}
}
}
}
/* Added by Daniel for CQ00138517, end */
}
}
}
}
}
break;
}
case TEL_EXT_ACTION_CMD: /* AT*BAND */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
/************************************************************************************
* F@: ciPOWERIND - GLOBAL API for GCF AT*POWERIND command
*
*/
RETURNCODE_T ciPOWERIND( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
INT32 powerInd;
/*
* Put parser index into the variable
*/
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciPOWERIND, "ciPOWERIND: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT*POWERIND? */
{
CHAR respBuf[40] = {0};
snprintf(respBuf,39, "*POWERIND: %d", gPowerind);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, respBuf);
break;
}
case TEL_EXT_SET_CMD: /* AT*POWERIND= */
{
if ( getExtValue(parameter_values_p, 0, &powerInd, TEL_AT_POWERIND_MODE_VAL_MIN, TEL_AT_POWERIND_MODE_VAL_MAX, TEL_AT_POWERIND_MODE_VAL_DEFAULT) == TRUE )
{
if (gPowerind != powerInd)
{
ret = DEV_SetPOWERIND(atHandle, powerInd);
gPowerindTmp = powerInd;
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciAPPOWERIND - GLOBAL API for GCF AT*APPOWERIND command
*
*/
RETURNCODE_T ciAPPOWERIND( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
INT32 powerInd;
TelAtParserID sAtpIndex;
char resp_str[32];
/*
* Put parser index into the variable
*/
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
sAtpIndex = *(TelAtParserID *)arg_p;
*xid_p = atHandle;
//DBGMSG(ciAPPOWERIND, "ciAPPOWERIND: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT*APPOWERIND=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*APPOWERIND: (0-1)\r\n");
break;
}
case TEL_EXT_GET_CMD: /* AT*APPOWERIND? */
{
snprintf(resp_str, sizeof(resp_str), "*APPOWERIND: %d\r", gAtpCtrl[sAtpIndex].AtpIndEnable);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, resp_str);
break;
}
case TEL_EXT_SET_CMD: /* AT*APPOWERIND= */
{
if ( getExtValue(parameter_values_p, 0, &powerInd, TEL_AT_APPOWERIND_MODE_VAL_MIN, TEL_AT_APPOWERIND_MODE_VAL_MAX, TEL_AT_APPOWERIND_MODE_VAL_DEFAULT) == TRUE )
{
gAtpCtrl[sAtpIndex].AtpIndEnable = powerInd;
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciWS46 - GLOBAL API for GCF AT+WS46 command
*
*/
RETURNCODE_T ciWS46( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
INT32 wirelessMode;
UINT8 networkMode, preferredMode;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciWS46, "ciWS46: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_SET_CMD: /* AT+WS46= */
{
BOOL cmdValid = FALSE;
if ( getExtValue(parameter_values_p, 0, &wirelessMode, TEL_AT_WIRELESS_NW_MODE_VAL_MIN, TEL_AT_WIRELESS_NW_MODE_VAL_MAX, TEL_AT_WIRELESS_NW_MODE_VAL_DEFAULT) == TRUE )
{
cmdValid = TRUE;
switch (wirelessMode)
{
case WDS_GERAN:
networkMode = CI_DEV_NW_GSM;
preferredMode = CI_DEV_NW_GSM;
break;
case WDS_UTRAN:
networkMode = CI_DEV_NW_UMTS;
preferredMode = CI_DEV_NW_UMTS;
break;
case WDS_GERAN_UTRAN_EUTRAN:
networkMode = CI_DEV_NW_GSM_UMTS_LTE;
preferredMode = CI_DEV_NW_GSM_UMTS_LTE;
break;
case WDS_EUTRAN:
networkMode = CI_DEV_NW_LTE;
preferredMode = CI_DEV_NW_LTE;
break;
case WDS_GERAN_UTRAN:
networkMode = CI_DEV_NW_GSM_UMTS;
preferredMode = CI_DEV_NW_GSM_UMTS;
break;
case WDS_GERAN_EUTRAN:
networkMode = CI_DEV_NW_GSM_LTE;
preferredMode = CI_DEV_NW_GSM_LTE;
break;
case WDS_UTRAN_EUTRAN:
networkMode = CI_DEV_NW_UMTS_LTE;
preferredMode = CI_DEV_NW_UMTS_LTE;
break;
default:
cmdValid = FALSE;
break;
}
}
if (cmdValid == TRUE)
{
ret = DEV_SetWirelessModeReq(atHandle, networkMode, preferredMode);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT+WS46? */
{
ret = DEV_GetWirelessModeReq(atHandle);
break;
}
case TEL_EXT_TEST_CMD: /* AT+WS46=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, "12,22,25,28,29,30,31");
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/* Added by Michal Bukai */
/************************************************************************************
* F@: ciSilentReset - GLOBAL API for GCF AT*CPRST command
*
*/
#if 0
RETURNCODE_T ciSilentReset( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
static CiDevPrimCommAssertReq commAssertReq;
/*
* Put parser index into the variable
*/
CiRequestHandle reqHandle;
TelAtParserID sAtpIndex = *(TelAtParserID *)arg_p;
reqHandle = RET_CI_REQ_HANDLE( sAtpIndex, CI_SG_ID_DEV );
*xid_p = reqHandle;
DBGMSG("%s: reqHandle = %d.\n", __FUNCTION__, reqHandle);
RESP_DEBUG((CHAR *)"Enter ciSilentReset", TRUE, FALSE);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT*CPRST=? */
{
RESP( reqHandle, (char *)"OK\r\n", TRUE, FALSE );
ret = CIRC_SUCCESS;
break;
}
case TEL_EXT_ACTION_CMD: /* AT*CPRST */
{
ret = ciRequest( gAtciSvgHandle[CI_SG_ID_DEV], CI_DEV_PRIM_COMM_ASSERT_REQ,
reqHandle, (void *)&commAssertReq );
break;
}
case TEL_EXT_GET_CMD: /* AT*CPRST? */
case TEL_EXT_SET_CMD: /* AT*CPRST= */
default:
{
ret = OPER_NOT_SUPPORTED;
break;
}
}
RESP_DEBUG((CHAR *)"Exit ciSilentReset", TRUE, TRUE);
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret, reqHandle);
return(rc);
}
#endif
/* Added by Michal Bukai*/
/************************************************************************************
* F@: ciCMER - GLOBAL API for GCF AT+CMER command
*
*/
RETURNCODE_T ciCMER( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_SUCCESS;
BOOL cmdValid = FALSE;
INT32 dwMode = 0;
INT32 dwKeyp = 0;
INT32 dwDisp = 0;
INT32 dwInd = 0;
INT32 dwBfr = 0;
CHAR AtRspBuf [50];
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciCMER, "ciCMER: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT+CMER=? */
{
/* display "+CMER: list of supported modes - non of the parameter is configurable" */
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CMER: (3), (0), (0), (0), (0)");
break;
}
case TEL_EXT_GET_CMD: /* AT+CMER? */
{
/* display "+CMER: current mode" */
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CMER: 3,0,0,0,0");
break;
}
case TEL_EXT_SET_CMD: /* AT+CMER= */
{
if ( getExtValue(parameter_values_p, 0, &dwMode, TEL_AT_CMER_MODE_VAL_DEFAULT, TEL_AT_CMER_MODE_VAL_DEFAULT, TEL_AT_CMER_MODE_VAL_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 1, &dwKeyp, TEL_AT_CMER_KEY_VAL_DEFAULT, TEL_AT_CMER_KEY_VAL_DEFAULT, TEL_AT_CMER_KEY_VAL_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 2, &dwDisp, TEL_AT_CMER_DIS_VAL_DEFAULT, TEL_AT_CMER_DIS_VAL_DEFAULT, TEL_AT_CMER_DIS_VAL_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 3, &dwInd, TEL_AT_CMER_IND_VAL_DEFAULT, TEL_AT_CMER_IND_VAL_DEFAULT, TEL_AT_CMER_IND_VAL_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 4, &dwBfr, TEL_AT_CMER_BUFFER_VAL_DEFAULT, TEL_AT_CMER_BUFFER_VAL_DEFAULT, TEL_AT_CMER_BUFFER_VAL_DEFAULT) == TRUE )
{
cmdValid = TRUE;
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
}
}
}
}
if (cmdValid != TRUE)
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
case TEL_EXT_ACTION_CMD: /* AT+CMER */
default:
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciCMEC - GLOBAL API for GCF AT+CMEC command
*
*/
RETURNCODE_T ciCMEC( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_SUCCESS;
BOOL cmdValid = FALSE;
INT32 dwKeyp = 0;
INT32 dwDisp = 0;
INT32 dwInd = 0;
INT32 dwTscrn = 0;
CHAR AtRspBuf [50];
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciCMEC, "ciCMEC: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT+CMEC=? */
{
/* display "+CMEC: list of supported modes - non of the parameter is configurable" */
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CMEC: (0), (0), (0), (0)");
break;
}
case TEL_EXT_GET_CMD: /* AT+CMEC? */
{
/* display "+CMEC: current mode" */
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CMEC: 0,0,0,0");
break;
}
case TEL_EXT_SET_CMD: /* AT+CMEC= */
{
if ( getExtValue(parameter_values_p, 0, &dwKeyp, TEL_AT_CMEC_KEY_VAL_DEFAULT, TEL_AT_CMEC_KEY_VAL_DEFAULT, TEL_AT_CMEC_KEY_VAL_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 1, &dwDisp, TEL_AT_CMEC_DIS_VAL_DEFAULT, TEL_AT_CMEC_DIS_VAL_DEFAULT, TEL_AT_CMEC_DIS_VAL_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 2, &dwInd, TEL_AT_CMEC_IND_VAL_DEFAULT, TEL_AT_CMEC_IND_VAL_DEFAULT, TEL_AT_CMEC_IND_VAL_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 3, &dwTscrn, TEL_AT_CMEC_TSCRN_VAL_DEFAULT, TEL_AT_CMEC_TSCRN_VAL_DEFAULT, TEL_AT_CMEC_TSCRN_VAL_DEFAULT) == TRUE )
{
cmdValid = TRUE;
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
}
}
}
if (cmdValid != TRUE)
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
case TEL_EXT_ACTION_CMD: /* AT+CMEC */
default:
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#define READ_FILE(path, buf) (void)readFile(path, buf, sizeof(buf));
/************************************************************************************
* F@: ciCBC - GLOBAL API for GCF AT+CBC command
*
*/
RETURNCODE_T ciCBC( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
#define CHARGER_STATUS_PATH "/sys/class/power_supply/battery/status"
#define BATTERY_PRESENT_PATH "/sys/class/power_supply/battery/present"
#define BATTERY_CAPACITY_PATH "/sys/class/power_supply/battery/capacity"
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CHAR rspStr[MAX_OUT_BUFFER];
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
*xid_p = atHandle;
switch ((int)op) {
case TEL_EXT_ACTION_CMD: /* AT+CBC */
{
char present[4] = {0};
DevBatteryStatus bcs;
int bcl;
READ_FILE(BATTERY_PRESENT_PATH, present);
if (atoi(present) == 1) {
/* battery is present */
char charger[20] = {0}, capacity[4] = {0};
READ_FILE(CHARGER_STATUS_PATH, charger);
READ_FILE(BATTERY_CAPACITY_PATH, capacity);
bcl = atoi(capacity);
if (!strncmp(charger, "Charging", strlen("Charging")))
bcs = DEV_BATTERY_STAT_POWER_BY_CHARGER;
else if ((!strncmp(charger, "Not charging", strlen("Not charging")))
|| (!strncmp(charger, "Full", strlen("Full"))))
bcs = DEV_BATTERY_STAT_POWER_BY_BATTERY;
else if (!strncmp(charger, "Discharging", strlen("Discharging"))) {
if (bcl == 0)
bcs = DEV_BATTERY_STAT_POWER_FAULT;
else
bcs = DEV_BATTERY_STAT_POWER_BY_BATTERY;
} else { /* "Unknown" */
bcs = DEV_BATTERY_STAT_POWER_FAULT;
bcl = 0;
}
} else {
/* battery is absent */
bcs = DEV_BATTERY_STAT_NO_BATTERY;
bcl = 0;
}
sprintf((char *)rspStr, "+CBC: %d,%d", bcs, bcl);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)rspStr);
break;
}
case TEL_EXT_TEST_CMD: /* AT+CBC=? */
case TEL_EXT_GET_CMD: /* AT+CBC? */
case TEL_EXT_SET_CMD: /* AT+CBC= */
default:
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
/ * F@: ciEEMOPT - GLOBAL API for AT+EEMOPT-command
*
*/
RETURNCODE_T ciEEMOPT( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiDevEngModeReportOption *pEngModeRepOpt;
int *pCurrTimeVal;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
char AtRspBuf[50];
if (!GET_SIM1_FLAG(atHandle)) {
pEngModeRepOpt = &gEngModeRepOpt;
pCurrTimeVal = &gCurrTimeVal;
} else {
pEngModeRepOpt = &gEngModeRepOpt_1;
pCurrTimeVal = &gCurrTimeVal_1;
}
*xid_p = atHandle;
//DBGMSG(ciEEMOPT, "ciEEMOPT: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_TEST_CMD: /* AT+EEMOPT=? */
{
ATRESP( atHandle, 0, 0, (char *)"AT+EEMOPT=0 :Turn off indicator. This is default mode after ME bootup");
ATRESP( atHandle, 0, 0, (char *)"AT+EEMOPT=1 :Set to query mode. User can use +EEMGINFO to query network parameter");
ATRESP( atHandle, 0, 0, (char *)"AT+EEMOPT=2,<interval> :Set to periodic mode. Report EM info in <value> seconds");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_SUPPRESS, 0, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT+EEMOPT=*/
{
INT32 modeVal, timeVal;
BOOL cmdValid = FALSE;
if ( getExtValue(parameter_values_p, 0, &modeVal, TEL_AT_EEMOPT_0_MODE_VAL_MIN, TEL_AT_EEMOPT_0_MODE_VAL_MAX, TEL_AT_EEMOPT_0_MODE_VAL_DEFAULT) == TRUE )
{
if(getExtValue( parameter_values_p, 1, &timeVal, TEL_AT_EEMOPT_1_INTERVAL_VAL_MIN, TEL_AT_EEMOPT_1_INTERVAL_VAL_MAX, TEL_AT_EEMOPT_1_INTERVAL_VAL_DEFAULT) == TRUE)
{
cmdValid = TRUE;
ret = DEV_SetEngModeIndicatorOption(atHandle, modeVal, timeVal);
}
}
if(!cmdValid)
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
case TEL_EXT_GET_CMD: /* AT+EEMOPT? */
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_PERIODIC)
sprintf((char*)AtRspBuf, "+EEMOPT: %d,%d\r\n", *pEngModeRepOpt, *pCurrTimeVal);
else
sprintf((char*)AtRspBuf, "+EEMOPT: %d\r\n", *pEngModeRepOpt);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, AtRspBuf);
break;
}
case TEL_EXT_ACTION_CMD: /* AT+EEMOPT */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
/ * F@: ciEEMOPT - GLOBAL API for AT+EEMGINFO-command
*
*/
RETURNCODE_T ciEEMGINFO( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiDevEngModeReportOption *pEngModeRepOpt;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
if (!GET_SIM1_FLAG(atHandle)) {
pEngModeRepOpt = &gEngModeRepOpt;
} else {
pEngModeRepOpt = &gEngModeRepOpt_1;
}
*xid_p = atHandle;
//DBGMSG(ciEEMGINFO, "ciEEMGINFO: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_GET_CMD: /* AT+EEMGINFO? */
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_NONE) //enquery parameters without enable ENG Mode
ret = DEV_GetEngModeInfo(atHandle, 1);
else if(*pEngModeRepOpt == CI_DEV_EM_OPTION_REQUEST)
ret = DEV_GetEngModeInfo(atHandle, 0);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_ALLOWED, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT+EEMGINFO=*/
{
UINT32 forceNcell = 0;
if(getExtValue( parameter_values_p, 0, (int *)&forceNcell, TEL_AT_EEMGINFO_TYPE_VAL_MIN, TEL_AT_EEMGINFO_TYPE_VAL_MAX, TEL_AT_EEMGINFO_TYPE_VAL_DEFAULT) == TRUE)
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_NONE)
{
ret = DEV_GetEngModeInfo(atHandle, (forceNcell==1)?2 : 1);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_ALLOWED, NULL);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_TEST_CMD: /* AT+EEMGINFO=? */
case TEL_EXT_ACTION_CMD: /* AT+EEMGINFO */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#ifdef CUSTZ
/************************************************************************************
/ * F@: ciZAIRINFO - GLOBAL API for AT*ZAIRINFO-command
*
*/
RETURNCODE_T ciZAIRINFO( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiDevEngModeReportOption *pEngModeRepOpt;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
if (!GET_SIM1_FLAG(atHandle)) {
pEngModeRepOpt = &gEngModeRepOpt;
} else {
pEngModeRepOpt = &gEngModeRepOpt_1;
}
*xid_p = atHandle;
//DBGMSG(ciEEMGINFO, "ciEEMGINFO: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_GET_CMD: /* AT*ZAIRINFO? */
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_NONE) //enquery parameters without enable ENG Mode
ret = DEV_GetZAIRInfo(atHandle, 1);
else if(*pEngModeRepOpt == CI_DEV_EM_OPTION_REQUEST)
ret = DEV_GetZAIRInfo(atHandle, 0);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_ALLOWED, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT*ZAIRINFO=*/
case TEL_EXT_TEST_CMD: /* AT*ZAIRINFO=? */
case TEL_EXT_ACTION_CMD: /* AT*ZAIRINFO */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
/ * F@: ciZCQI - GLOBAL API for AT*ZCQI-command
*
*/
RETURNCODE_T ciZCQI( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiDevEngModeReportOption *pEngModeRepOpt;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
if (!GET_SIM1_FLAG(atHandle)) {
pEngModeRepOpt = &gEngModeRepOpt;
} else {
pEngModeRepOpt = &gEngModeRepOpt_1;
}
*xid_p = atHandle;
//DBGMSG(ciZCQI, "ciZCQI: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
//close use AT*ZCQI? indication
switch (op)
{
case TEL_EXT_GET_CMD: /* AT*ZCQI? */
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_NONE) //enquery parameters without enable ENG Mode
ret = DEV_GetZCQI(atHandle, 1);
else if(*pEngModeRepOpt == CI_DEV_EM_OPTION_REQUEST)
ret = DEV_GetZCQI(atHandle, 0);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_ALLOWED, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT*ZCQI= */
case TEL_EXT_TEST_CMD: /* AT*ZCQI=? */
case TEL_EXT_ACTION_CMD: /* AT*ZCQI */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
RETURNCODE_T ciZFactoryReset( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciTEMPTEST, "ciZFactoryReset: atHandle = %d.\n", atHandle);
switch ( op ) {
case TEL_EXT_TEST_CMD: /* AT*ZFACTORY=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*ciZFactoryReset");
break;
}
case TEL_EXT_SET_CMD: /* AT*ZFACTORY= */
case TEL_EXT_GET_CMD: /* AT*ZFACTORY? */
case TEL_EXT_ACTION_CMD: /* AT*ZFACTORY */
{
ASR_flag tag;
int rs = get_asr_flag(&tag);
if(rs < 0)
{
WARNMSG(ciZFactoryReset, "read asr flag error\n");
ret = ATRESP( atHandle,ATCI_RESULT_CODE_ERROR,CME_UNKNOWN,NULL);
}
else
{
tag.Production_Mode_Flag = 0;
tag.ramdump[0] = RAMDUMPID;
tag.ramdump[1] = 0;
tag.cplog[0] = CPLOGID;
tag.cplog[1] = 0;
#ifdef CONFIG_EEH_FORCE_SILENT_RESET
tag.eehP[0] = EEHPID;
tag.eehP[1] = 0;
#endif
rs = write_asr_flag(&tag);
if (rs < 0) {
WARNMSG(ciZFactoryReset1, "write asr flag error\n");
ret = ATRESP( atHandle,ATCI_RESULT_CODE_ERROR,CME_UNKNOWN,NULL);
} else {
//DBGMSG(ciZFactoryReset2, "DEV_SetZFactoryReq\n");
ret = DEV_SetZFactoryReq(atHandle);
}
}
break;
}
default:
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
/************************************************************************************
/ * F@: ciSINR - GLOBAL API for AT*SINR-command
*
*/
RETURNCODE_T ciSINR( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiDevEngModeReportOption *pEngModeRepOpt;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
if (!GET_SIM1_FLAG(atHandle)) {
pEngModeRepOpt = &gEngModeRepOpt;
} else {
pEngModeRepOpt = &gEngModeRepOpt_1;
}
*xid_p = atHandle;
//DBGMSG(ciSINR, "ciSINR: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_ACTION_CMD: /* AT*SINR */
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_REQUEST)
ret = DEV_GetSinrReq(atHandle);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_ALLOWED, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
/ * F@: ciRSSI - GLOBAL API for AT*RSSI-command
*
*/
RETURNCODE_T ciRSSI( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiDevEngModeReportOption *pEngModeRepOpt;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
if (!GET_SIM1_FLAG(atHandle)) {
pEngModeRepOpt = &gEngModeRepOpt;
} else {
pEngModeRepOpt = &gEngModeRepOpt_1;
}
*xid_p = atHandle;
//DBGMSG(ciRSSI, "ciRSSI: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_ACTION_CMD: /* AT*RSSI */
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_REQUEST)
ret = DEV_GetRssiReq(atHandle);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_ALLOWED, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
/ * F@: ciRSRP - GLOBAL API for AT*RSRP-command
*
*/
RETURNCODE_T ciRSRP( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiDevEngModeReportOption *pEngModeRepOpt;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
if (!GET_SIM1_FLAG(atHandle)) {
pEngModeRepOpt = &gEngModeRepOpt;
} else {
pEngModeRepOpt = &gEngModeRepOpt_1;
}
*xid_p = atHandle;
//DBGMSG(ciRSRP, "ciRSRP: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_ACTION_CMD: /* AT*RSRP */
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_REQUEST)
ret = DEV_GetRsrpReq(atHandle);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_ALLOWED, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
/ * F@: ciRSRPP - GLOBAL API for AT*RSRPP-command
*
*/
RETURNCODE_T ciRSRPP( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiDevEngModeReportOption *pEngModeRepOpt;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
if (!GET_SIM1_FLAG(atHandle)) {
pEngModeRepOpt = &gEngModeRepOpt;
} else {
pEngModeRepOpt = &gEngModeRepOpt_1;
}
*xid_p = atHandle;
//DBGMSG(ciRSRPP, "ciRSRPP: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_ACTION_CMD: /* AT*RSRPP */
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_REQUEST)
ret = DEV_GetRsrpPReq(atHandle);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_ALLOWED, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
/ * F@: ciRSRPS - GLOBAL API for AT*RSRPS-command
*
*/
RETURNCODE_T ciRSRPS( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiDevEngModeReportOption *pEngModeRepOpt;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
if (!GET_SIM1_FLAG(atHandle)) {
pEngModeRepOpt = &gEngModeRepOpt;
} else {
pEngModeRepOpt = &gEngModeRepOpt_1;
}
*xid_p = atHandle;
//DBGMSG(ciRSRPS, "ciRSRPS: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_ACTION_CMD: /* AT*RSRPS */
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_REQUEST)
ret = DEV_GetRsrpSReq(atHandle);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_ALLOWED, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
/ * F@: ciRSRQ - GLOBAL API for AT*RSRQ-command
*
*/
RETURNCODE_T ciRSRQ( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiDevEngModeReportOption *pEngModeRepOpt;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
if (!GET_SIM1_FLAG(atHandle)) {
pEngModeRepOpt = &gEngModeRepOpt;
} else {
pEngModeRepOpt = &gEngModeRepOpt_1;
}
*xid_p = atHandle;
//DBGMSG(ciRSRQ, "ciRSRQ: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_ACTION_CMD: /* AT*RSRQ */
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_REQUEST)
ret = DEV_GetRsrqReq(atHandle);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_ALLOWED, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
/ * F@: ciRSRQP - GLOBAL API for AT*RSRQP-command
*
*/
RETURNCODE_T ciRSRQP( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiDevEngModeReportOption *pEngModeRepOpt;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
if (!GET_SIM1_FLAG(atHandle)) {
pEngModeRepOpt = &gEngModeRepOpt;
} else {
pEngModeRepOpt = &gEngModeRepOpt_1;
}
*xid_p = atHandle;
//DBGMSG(ciRSRQP, "ciRSRQP: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_ACTION_CMD: /* AT*RSRQP */
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_REQUEST)
ret = DEV_GetRsrqPReq(atHandle);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_ALLOWED, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
/ * F@: ciRSRQS - GLOBAL API for AT*RSRQS-command
*
*/
RETURNCODE_T ciRSRQS( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiDevEngModeReportOption *pEngModeRepOpt;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
if (!GET_SIM1_FLAG(atHandle)) {
pEngModeRepOpt = &gEngModeRepOpt;
} else {
pEngModeRepOpt = &gEngModeRepOpt_1;
}
*xid_p = atHandle;
//DBGMSG(ciRSRQS, "ciRSRQS: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_ACTION_CMD: /* AT*RSRQS */
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_REQUEST)
ret = DEV_GetRsrqSReq(atHandle);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_ALLOWED, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
/ * F@: ciCQI - GLOBAL API for AT*CQI-command
*
*/
RETURNCODE_T ciCQI( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiDevEngModeReportOption *pEngModeRepOpt;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
if (!GET_SIM1_FLAG(atHandle)) {
pEngModeRepOpt = &gEngModeRepOpt;
} else {
pEngModeRepOpt = &gEngModeRepOpt_1;
}
*xid_p = atHandle;
//DBGMSG(ciCQI, "ciCQI: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_ACTION_CMD: /* AT*CQI */
{
if (*pEngModeRepOpt == CI_DEV_EM_OPTION_REQUEST)
ret = DEV_GetCqiReq(atHandle);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_ALLOWED, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#define TEL_AT_LPNWUL_1_LEN_VAL_MIN 0
#define TEL_AT_LPNWUL_1_LEN_VAL_MAX 2000
#define TEL_AT_LPNWUL_1_LEN_VAL_DEFAULT 480
#define TEL_AT_LPNWUL_2_COUNT_VAL_MIN 0
#define TEL_AT_LPNWUL_2_COUNT_VAL_MAX 20
#define TEL_AT_LPNWUL_2_COUNT_VAL_DEFAULT 0
#define TEL_AT_LPNWUL_3_TYPE_VAL_MIN 0
#define TEL_AT_LPNWUL_3_TYPE_VAL_MAX 4
#define TEL_AT_LPNWUL_3_TYPE_VAL_DEFAULT 0
#define TEL_AT_LPNWUL_4_FINAL_VAL_MIN 0
#define TEL_AT_LPNWUL_4_FINAL_VAL_MAX 1
#define TEL_AT_LPNWUL_4_FINAL_VAL_DEFAULT 0
#define TEL_AT_LPNWUL_6_ADDINFOLEN_VAL_MIN 0
#define TEL_AT_LPNWUL_6_ADDINFOLEN_VAL_MAX CI_DEV_MAX_ADD_INFO_LEN
#define TEL_AT_LPNWUL_6_ADDINFOLEN_VAL_DEFAULT 0
/************************************************************************************
/ * F@: ciLPNWUL - GLOBAL API for AT+LPNWUL-command
*
*/
RETURNCODE_T ciLPNWUL( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciLPNWUL, "ciLPNWUL: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT+LPNWUL=*/
{
CHAR msg_data[AT_CMD_MAX_AGPS_MSG_SIZE*2 + 2];
INT16 len;
INT32 msg_data_len;
INT32 count;
INT32 bearer_type;
INT32 isFinalRsp;
BOOL cmdValid = FALSE;
UINT8 add_info[CI_DEV_MAX_ADD_INFO_LEN*2 + 2];
INT32 add_info_len = 0;
memset(add_info, 0, sizeof(add_info));
if(getExtString(parameter_values_p, 0, msg_data, AT_CMD_MAX_AGPS_MSG_SIZE*2 + 1, &len, NULL) == TRUE)
{
if(getExtValue( parameter_values_p, 1, &msg_data_len, TEL_AT_LPNWUL_1_LEN_VAL_MIN, TEL_AT_LPNWUL_1_LEN_VAL_MAX, TEL_AT_LPNWUL_1_LEN_VAL_DEFAULT) == TRUE)
{
if(getExtValue( parameter_values_p, 2, &count, TEL_AT_LPNWUL_2_COUNT_VAL_MIN, TEL_AT_LPNWUL_2_COUNT_VAL_MAX, TEL_AT_LPNWUL_2_COUNT_VAL_DEFAULT) == TRUE)
{
if(getExtValue( parameter_values_p, 3, &bearer_type, TEL_AT_LPNWUL_3_TYPE_VAL_MIN, TEL_AT_LPNWUL_3_TYPE_VAL_MAX, TEL_AT_LPNWUL_3_TYPE_VAL_DEFAULT) == TRUE)
{
if(getExtValue( parameter_values_p, 4, &isFinalRsp, TEL_AT_LPNWUL_4_FINAL_VAL_MIN, TEL_AT_LPNWUL_4_FINAL_VAL_MAX, TEL_AT_LPNWUL_4_FINAL_VAL_DEFAULT) == TRUE)
{
cmdValid = TRUE;
if(getExtString(parameter_values_p, 5, (CHAR *)add_info, CI_DEV_MAX_ADD_INFO_LEN*2 + 1, &len, NULL) == TRUE)
{
//DBGMSG(ciLPNWUL1, "ciLPNWUL: add_info:%s\n", add_info);
}
if(getExtValue( parameter_values_p, 6, &add_info_len, TEL_AT_LPNWUL_6_ADDINFOLEN_VAL_MIN, TEL_AT_LPNWUL_6_ADDINFOLEN_VAL_MAX, TEL_AT_LPNWUL_6_ADDINFOLEN_VAL_DEFAULT) == TRUE)
{
//DBGMSG(ciLPNWUL2, "ciLPNWUL: add_info_len:%d\n", add_info_len);
}
/* set to CI_DEV_PRIM_LP_NWUL_MSG_REQ*/
ret = DEV_setLPNWUL(atHandle, (UINT8 *)msg_data, msg_data_len, count, bearer_type, isFinalRsp, add_info, (UINT32) add_info_len);
}
}
}
}
}
if(!cmdValid)
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
case TEL_EXT_TEST_CMD: /* AT+LPNWUL=? */
case TEL_EXT_GET_CMD: /* AT+LPNWUL? */
case TEL_EXT_ACTION_CMD: /* AT+LPNWUL */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciLPECID - GLOBAL API for GCF AT+LPECID command
*
************************************************************************************/
RETURNCODE_T ciLPECID( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciLPECID, "ciLPECID: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_ACTION_CMD: /* AT+LPECID */
{
ret = DEV_GetLPECID(atHandle);
break;
}
case TEL_EXT_TEST_CMD: /* AT+LPECID =? */
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+LPECID\r\n");
break;
}
case TEL_EXT_GET_CMD: /* AT+LPECID? */
case TEL_EXT_SET_CMD: /* AT+LPECID = */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#define TEL_AT_LPOTDOAREQ_LEN_VAL_MIN 0
#define TEL_AT_LPOTDOAREQ_LEN_VAL_MAX 4096
#define TEL_AT_LPOTDOAREQ_LEN_VAL_DEFAULT 2660
#define TEL_AT_LPOTDOAREQ_COUNT_VAL_MIN 0
#define TEL_AT_LPOTDOAREQ_COUNT_VAL_MAX 6
#define TEL_AT_LPOTDOAREQ_COUNT_VAL_DEFAULT 0
/************************************************************************************
+ * F@: ciLPECID - GLOBAL API for GCF AT+ciLPOTDOAREQ command
+ *
+ ************************************************************************************/
RETURNCODE_T ciLPOTDOAREQ( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciLPOTDOAREQ, "ciLPOTDOAREQ: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT+LPOTDOAREQ = */
{
CHAR msg_data[(AT_CMD_MAX_AGPS_MSG_SIZE<<1) + 2];
//CHAR msg_data[(sizeof(CiDevPrimLpOtdoaMeasReq)*2) + 2];
INT32 len, msg_data_len;
INT32 count;
BOOL cmdValid = FALSE;
if(getExtString(parameter_values_p, 0, msg_data, AT_CMD_MAX_AGPS_MSG_SIZE<<1, (INT16 *)&len, NULL) == TRUE)
//if(getExtString(parameter_values_p, 0, msg_data, (sizeof(CiDevPrimLpOtdoaMeasReq)*2) + 1, (INT16 *)&len, NULL) == TRUE)
{
if(getExtValue( parameter_values_p, 1, &msg_data_len, TEL_AT_LPOTDOAREQ_LEN_VAL_MIN, TEL_AT_LPOTDOAREQ_LEN_VAL_MAX, TEL_AT_LPOTDOAREQ_LEN_VAL_DEFAULT) == TRUE)
{
if(getExtValue( parameter_values_p, 2, &count, TEL_AT_LPOTDOAREQ_COUNT_VAL_MIN, TEL_AT_LPOTDOAREQ_COUNT_VAL_MAX, TEL_AT_LPOTDOAREQ_COUNT_VAL_DEFAULT) == TRUE)
{
cmdValid = TRUE;
//DBGMSG(ciLPOTDOAREQ1, "ciLPOTDOAREQ: msg_data_len:%d, count: %d\n", msg_data_len, count);
//DBGMSG(ciLPOTDOAREQ2, "ciLPOTDOAREQ: msg_data:%s\n", msg_data);
/* set to CI_DEV_PRIM_LP_OTDOA_MEAS_REQ*/
ret = DEV_GetLPOtdoaReq(atHandle, (UINT8 *)msg_data, msg_data_len,count);
}
}
}
if(!cmdValid)
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
case TEL_EXT_TEST_CMD: /* AT+LPOTDOAREQ =? */
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+LPOTDOAREQ\r\n");
break;
}
case TEL_EXT_ACTION_CMD: /* AT+LPOTDOAREQ */
case TEL_EXT_GET_CMD: /* AT+LPOTDOAREQ? */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciLPECID - GLOBAL API for GCF AT+ciLPOTDOAABORT command
*
************************************************************************************/
RETURNCODE_T ciLPOTDOAABORT( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciLPOTDOAABORT, "ciLPOTDOAABORT: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_ACTION_CMD: /* AT+LPOTDOAABORT */
{
ret = DEV_SetLPOtdoaAbort(atHandle);
break;
}
case TEL_EXT_TEST_CMD: /* AT+LPOTDOAABORT =? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+LPOTDOAABORT\r\n");
break;
}
case TEL_EXT_GET_CMD: /* AT+LPOTDOAABORT? */
case TEL_EXT_SET_CMD: /* AT+LPOTDOAABORT = */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciCKPD - GLOBAL API for GCF AT+CKPD command
*
* only s/S Special Keys supported. (send key)
*
* */
RETURNCODE_T ciCKPD(const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
int time = 0, pause = 0;
INT16 key_string_len = 0;
CHAR key_string[TEL_AT_CKPD_LENGTH_KEY_STRING + ATCI_NULL_TERMINATOR_LENGTH];
*xid_p = atHandle;
//DBGMSG(ciCKPD, "ciCKPD: atHandle = %d.\n", atHandle);
/* Check the format of the request. */
switch (op)
{
case TEL_EXT_TEST_CMD: /* AT+CKPD=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CKPD: <keys>[,<time>[,<pause>]]\r\n");
break;
}
case TEL_EXT_ACTION_CMD: /* AT+CKPD */
{
if (getExtString(parameter_values_p, 0, key_string, TEL_AT_CKPD_LENGTH_KEY_STRING + ATCI_NULL_TERMINATOR_LENGTH, &key_string_len, NULL) == TRUE)
{
if (getExtValue(parameter_values_p, 1, &time, TEL_AT_CKPD_1_VAL_MIN, TEL_AT_CKPD_1_VAL_MAX, TEL_AT_CKPD_1_VAL_DEFAULT) == TRUE)
{
if (getExtValue(parameter_values_p, 2, &pause, TEL_AT_CKPD_2_VAL_MIN, TEL_AT_CKPD_2_VAL_MAX, TEL_AT_CKPD_2_VAL_DEFAULT) == TRUE)
{
if ((key_string_len > 0 ) && ( (key_string[key_string_len-1]=='s') || (key_string[key_string_len-1]=='S')) )
{
key_string[key_string_len-1] = '\0';
ret = CC_Dial(atHandle, (CHAR *)key_string, CICC_BASIC_CMODE_VOICE, CICC_CALLOPTIONS_NONE);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
}
}
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/* SV */
/************************************************************************************
* F@: ciStarCGSN - GLOBAL API for AT*CGSN command
*
*/
RETURNCODE_T ciStarCGSN(
const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciStarCGSN, "ciStarCGSN: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_GET_CMD: /* AT*CGSN? */
{
ret = DEV_GetSoftwareVersionNumber(atHandle);
break;
}
case TEL_EXT_TEST_CMD: /* AT*CGSN=? */
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CGSN: <sv>\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT*CGSN= */
{
char sv[3];
INT16 len;
if(getExtString(parameter_values_p, 0, (CHAR *)sv, 2, &len, NULL) == TRUE)
{
if(len != 2)
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
}
else
{
ret = DEV_SetSoftwareVersionNumber(atHandle, sv);
}
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
case TEL_EXT_ACTION_CMD: /* AT*CGSN */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciStarMODEMTYPE - GLOBAL API for AT*MODEMTYPE -command
*
*/
RETURNCODE_T ciStarMODEMTYPE( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciStarMODEMTYPE, "ciStarMODEMTYPE: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_GET_CMD: /* AT*MODEMTYPE? */
{
int modem_type;
unsigned long chipid;
char buf[100];
if (get_chipid(&chipid) > 0)
{
//DBGMSG(ciStarMODEMTYPE1, "ciStarMODEMTYPE: chip id = 0x%x.\n", chipid);
switch (chipid & MODEM_FLAG_MASK)
{
case PXA910_MODEM_FLAG:
modem_type = PXA910_MODEM;
break;
case PXA920_MODEM_FLAG:
modem_type = PXA920_MODEM;
break;
default:
modem_type = UNKNOWN_MODEM;
break;
}
sprintf(buf, "*MODEMTYPE: %d\r\n", modem_type);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, buf);
}
else
{
WARNMSG(ciStarMODEMTYPE2, "ciStarMODEMTYPE: Can not get chip id.\n");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
}
break;
}
case TEL_EXT_ACTION_CMD: /* AT*MODEMTYPE */
case TEL_EXT_TEST_CMD: /* AT*MODEMTYPE=? */
case TEL_EXT_SET_CMD: /* AT*MODEMTYPE= */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciStarHTCCTO - GLOBAL API for AT*HTCCTO -command
*
*/
RETURNCODE_T ciStarHTCCTO( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciStarHTCCTO, "ciStarHTCCTO: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*HTCCTO= */
{
CHAR commandName[utlAT_MAX_COMMAND_LENGTH_WITH_PREFIX];
INT16 len;
int mode, timeout;
BOOL cmdValid = FALSE;
if(getExtString(parameter_values_p, 0, commandName, utlAT_MAX_COMMAND_LENGTH_WITH_PREFIX - 1, &len, NULL) == TRUE)
{
if(getExtValue( parameter_values_p, 1, &mode, TEL_AT_HTCCTO_2_MODE_VAL_MIN, TEL_AT_HTCCTO_2_MODE_VAL_MAX, TEL_AT_HTCCTO_2_MODE_VAL_DEFAULT) == TRUE)
{
if(getExtValue( parameter_values_p, 2, &timeout, 0, 65536, 0) == TRUE)
{
cmdValid = TRUE;
}
}
}
if(cmdValid == TRUE)
{
if(utlAtCommandTimeoutModify((char *)commandName, mode, timeout))
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_UNKNOWN, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
case TEL_EXT_ACTION_CMD: /* AT*HTCCTO */
case TEL_EXT_TEST_CMD: /* AT*HTCCTO=? */
case TEL_EXT_GET_CMD: /* AT*HTCCTO? */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciStarSWITCHMODEM - GLOBAL API for AT*SWITCHMODEM -command
*
*/
RETURNCODE_T ciStarSWITCHMODEM( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
#if 0
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
int type = 0, old_type = 0, size = 0;
unsigned int cp_type = 0, switch_cp_type = 0;
*xid_p = atHandle;
//DBGMSG(ciStarSWITCHMODEM, "ciStarSWITCHMODEM: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*SWITCHMODEM= */
{
if(getExtValue( parameter_values_p, 0, &type, 3, 4, 3) == TRUE)
{
if((type != atoi(LWG_CP)) && (type != atoi(LTG_CP)))
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
{
cp_type = get_cp_type();
if((cp_type == LWG_3MODE)||(cp_type == LTG_3MODE))
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
{
if(cp_type == LWG_5MODE)
{
old_type = atoi(LWG_CP);
switch_cp_type = LTG_5MODE;
}
else if(cp_type == LTG_5MODE)
{
old_type = atoi(LTG_CP);
switch_cp_type = LWG_5MODE;
}
else
{
old_type = 0;
}
/* the cp wanna switched to is exist */
if ((old_type != type) && (old_type != 0))
{
/* Modem mode changed, save the new value and reset Modem */
if(!save_cp_type(switch_cp_type))
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_SUPPRESS, 0, NULL);
if(cp_silent_reset_on_req("Switch Modem", 1) != 0)
{
/* Swtch failed, restore modem type */
if(save_cp_type(cp_type))
{
WARNMSG(ciStarSWITCHMODEM2, "Fail to restore old modem type 0x%x", cp_type);
}
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_UNKNOWN, NULL);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_NULL, 0, "OK");
}
}
else
{
WARNMSG(ciStarSWITCHMODEM3, "save_cp_type error\n");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_UNKNOWN, NULL);
}
}
else /* Already in this Mode, return success*/
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
}
}
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*SWITCHMODEM?*/
{
int cp_prop = 0;
char buf[100] = {0};
cp_type = get_cp_type();
switch(cp_type)
{
case LWG_3MODE:
case LWG_5MODE:
{
cp_prop = atoi(LWG_CP);
break;
}
case LTG_3MODE:
case LTG_5MODE:
{
cp_prop = atoi(LTG_CP);
break;
}
default:
{
cp_prop = 0;
break;
}
}
if ((cp_prop != atoi(LWG_CP)) && (cp_prop != atoi(LTG_CP)))
{
WARNMSG(ciStarSWITCHMODEM3, "Wrong current cp type\n");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_UNKNOWN, NULL);
}
else
{
sprintf(buf, "*SWITCHMODEM: %d\r\n", cp_prop);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, buf);
}
break;
}
case TEL_EXT_ACTION_CMD: /* AT*SWITCHMODEM */
case TEL_EXT_TEST_CMD: /* AT*SWITCHMODEM=? */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
#endif
return 0;
}
/************************************************************************************
* F@: ciStarMODEMRESET - GLOBAL API for AT*MODEMRESET -command
*
*/
RETURNCODE_T ciStarMODEMRESET( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciStarMODEMRESET, "ciStarMODEMRESET: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*MODEMRESET= */
{
char buf[512];
INT16 len;
int force;
if(getExtString(parameter_values_p, 0, (CHAR *)buf, sizeof(buf) - 1, &len, NULL) == TRUE)
{
if(getExtValue( parameter_values_p, 1, &force, 0, 1, 0) == TRUE)
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_SUPPRESS, 0, NULL);
if(cp_silent_reset_on_req(buf, force) != 0)
{
WARNMSG(ciStarMODEMRESET1, "cp silent reset req error\n");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_UNKNOWN, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_NULL, 0, "OK");
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
case TEL_EXT_ACTION_CMD: /* AT*MODEMRESET */
case TEL_EXT_TEST_CMD: /* AT*MODEMRESET=? */
case TEL_EXT_GET_CMD: /* AT*MODEMRESET?*/
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciStarEHSDPA - GLOBAL API for AT*EHSDPA -command
*
*/
RETURNCODE_T ciStarEHSDPA( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
NumericRange hspaConfig_TD[] = {{0, 3}};
NumericRange dlCategory_TD[] = {{1, 11}, {13, 16}, {23, 23}, {35, 35}};
NumericRange ulCategory_TD[] = {{6, 6}};
NumericRange cpcState_TD[] = {{0, 0}};
NumericRange dpaCategoryExt_TD[] = {{0, 0}};
NumericRange edchCategoryExt_TD[] = {{0, 0}};
NumericRange fdpchState_TD[] = {{0, 0}};
NumericRange efdpchState_TD[] = {{0, 0}};
NumericRange efachState_TD[] = {{0, 0}};
NumericRange hspaConfig_UMTS[] = {{0,2}, {4,4}};
NumericRange dlCategory_UMTS[] = {{1, 12}};
NumericRange ulCategory_UMTS[] = {{1, 6}};
NumericRange cpcState_UMTS[] = {{0, 1}};
NumericRange dpaCategoryExt_UMTS[] = {{1, 14}};
NumericRange edchCategoryExt_UMTS[] = {{7, 7}};
NumericRange fdpchState_UMTS[] = {{0, 1}};
NumericRange efdpchState_UMTS[] = {{0, 1}};
NumericRange efachState_UMTS[] = {{0, 1}};
*xid_p = atHandle;
//DBGMSG(ciStarEHSDPA, "%s: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*EHSDPA= */
{
int mode, dl_category, ul_category, cpc_state, dpaCategoryExt, edchCategoryExt, fdpchState, efdpchState, efachState;
BOOL cmdValid = FALSE;
if(Is_TD_mode())
{
if(getExtValue( parameter_values_p, 0, &mode, 0, INT_MAX, TEL_AT_EHSDPA_0_MODE_VAL_DEFAULT) == TRUE
&& IsInValidRange(mode, hspaConfig_TD, sizeof(hspaConfig_TD) / sizeof(hspaConfig_TD[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 1, &dl_category, 0, INT_MAX, TEL_AT_EHSDPA_1_DL_CATEGORY_VAL_DEFAULT_TD) == TRUE
&& IsInValidRange(dl_category, dlCategory_TD, sizeof(dlCategory_TD) / sizeof(dlCategory_TD[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 2, &ul_category, 0, INT_MAX, TEL_AT_EHSDPA_2_UL_CATEGORY_VAL_DEFAULT_TD) == TRUE
&& IsInValidRange(ul_category, ulCategory_TD, sizeof(ulCategory_TD) / sizeof(ulCategory_TD[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 3, &cpc_state, 0, INT_MAX, TEL_AT_EHSDPA_3_CPC_STATE_VAL_DEFAULT_TD) == TRUE
&& IsInValidRange(cpc_state, cpcState_TD, sizeof(cpcState_TD) / sizeof(cpcState_TD[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 4, &dpaCategoryExt, 0, INT_MAX, TEL_AT_EHSDPA_4_DPA_CATEGORY_EXT_DEFAULT_TD) == TRUE
&& IsInValidRange(dpaCategoryExt, dpaCategoryExt_TD, sizeof(dpaCategoryExt_TD) / sizeof(dpaCategoryExt_TD[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 5, &edchCategoryExt, 0, INT_MAX, TEL_AT_EHSDPA_5_EDCH_CATEGORY_EXT_DEFAULT_TD) == TRUE
&& IsInValidRange(edchCategoryExt, edchCategoryExt_TD, sizeof(edchCategoryExt_TD) / sizeof(edchCategoryExt_TD[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 6, &fdpchState, 0, INT_MAX, TEL_AT_EHSDPA_6_FDPCH_STATE_DEFAULT_TD) == TRUE
&& IsInValidRange(fdpchState, fdpchState_TD, sizeof(fdpchState_TD) / sizeof(fdpchState_TD[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 7, &efdpchState, 0, INT_MAX, TEL_AT_EHSDPA_7_EFDPCH_STATE_DEFAULT_TD) == TRUE
&& IsInValidRange(efdpchState, efdpchState_TD, sizeof(efdpchState_TD) / sizeof(efdpchState_TD[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 7, &efachState, 0, INT_MAX, TEL_AT_EHSDPA_8_EFACH_STATE_DEFAULT_TD) == TRUE
&& IsInValidRange(efachState, efachState_TD, sizeof(efachState_TD) / sizeof(efachState_TD[0])) == TRUE)
{
cmdValid = TRUE;
}
}
}
}
}
}
}
}
}
}
else
{
if(getExtValue( parameter_values_p, 0, &mode, 0, INT_MAX, TEL_AT_EHSDPA_0_MODE_VAL_DEFAULT) == TRUE
&& IsInValidRange(mode, hspaConfig_UMTS, sizeof(hspaConfig_UMTS) / sizeof(hspaConfig_UMTS[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 1, &dl_category, 0, INT_MAX, TEL_AT_EHSDPA_1_DL_CATEGORY_VAL_DEFAULT_UMTS) == TRUE
&& IsInValidRange(dl_category, dlCategory_UMTS, sizeof(dlCategory_UMTS) / sizeof(dlCategory_UMTS[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 2, &ul_category, 0, INT_MAX, TEL_AT_EHSDPA_2_UL_CATEGORY_VAL_DEFAULT_UMTS) == TRUE
&& IsInValidRange(ul_category, ulCategory_UMTS, sizeof(ulCategory_UMTS) / sizeof(ulCategory_UMTS[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 3, &cpc_state, 0, INT_MAX, TEL_AT_EHSDPA_3_CPC_STATE_VAL_DEFAULT_UMTS) == TRUE
&& IsInValidRange(cpc_state, cpcState_UMTS, sizeof(cpcState_UMTS) / sizeof(cpcState_UMTS[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 4, &dpaCategoryExt, 0, INT_MAX, TEL_AT_EHSDPA_4_DPA_CATEGORY_EXT_DEFAULT_UMTS) == TRUE
&& IsInValidRange(dpaCategoryExt, dpaCategoryExt_UMTS, sizeof(dpaCategoryExt_UMTS) / sizeof(dpaCategoryExt_UMTS[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 5, &edchCategoryExt, 0, INT_MAX, TEL_AT_EHSDPA_5_EDCH_CATEGORY_EXT_DEFAULT_UMTS) == TRUE
&& IsInValidRange(edchCategoryExt, edchCategoryExt_UMTS, sizeof(edchCategoryExt_UMTS) / sizeof(edchCategoryExt_UMTS[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 6, &fdpchState, 0, INT_MAX, TEL_AT_EHSDPA_6_FDPCH_STATE_DEFAULT_UMTS) == TRUE
&& IsInValidRange(fdpchState, fdpchState_UMTS, sizeof(fdpchState_UMTS) / sizeof(fdpchState_UMTS[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 7, &efdpchState, 0, INT_MAX, TEL_AT_EHSDPA_7_EFDPCH_STATE_DEFAULT_UMTS) == TRUE
&& IsInValidRange(efdpchState, efdpchState_UMTS, sizeof(efdpchState_UMTS) / sizeof(efdpchState_UMTS[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 7, &efdpchState, 0, INT_MAX, TEL_AT_EHSDPA_7_EFDPCH_STATE_DEFAULT_UMTS) == TRUE
&& IsInValidRange(efdpchState, efdpchState_UMTS, sizeof(efdpchState_UMTS) / sizeof(efdpchState_UMTS[0])) == TRUE)
{
if(getExtValue( parameter_values_p, 7, &efachState, 0, INT_MAX, TEL_AT_EHSDPA_8_EFACH_STATE_DEFAULT_UMTS) == TRUE
&& IsInValidRange(efachState, efachState_UMTS, sizeof(efachState_UMTS) / sizeof(efachState_UMTS[0])) == TRUE)
{
cmdValid = TRUE;
}
}
}
}
}
}
}
}
}
}
}
if(cmdValid)
{
ret = DEV_SetHsdpaModeReq(atHandle, (UINT8)mode, (UINT8)dl_category, (UINT8)ul_category, (UINT8)cpc_state,
(UINT8)dpaCategoryExt, (UINT8)edchCategoryExt, (UINT8)fdpchState, (UINT8)efdpchState, (UINT8)efachState);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*EHSDPA? */
{
ret = DEV_GetHsdpaModeReq(atHandle);
break;
}
case TEL_EXT_TEST_CMD: /* AT*EHSDPA=? */
{
if(Is_TD_mode())
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*EHSDPA: (0-3),(1-11,13-16,23,35),(6),(0),(0),(0),(0),(0)");
else //coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*EHSDPA: (0-2,4),(1-12),(1-6),(0,1),(1-14),(7),(0,1),(0,1)");
break;
}
case TEL_EXT_ACTION_CMD: /* AT*EHSDPA*/
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#ifdef AT_PRODUCTION_CMNDS
/************************************************************************************
* F@: ciTDTR - GLOBAL API for AT*TDTR command
*
*/
RETURNCODE_T ciTDTR( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciTDTR, "ciTDTR: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT*TDTR=? */
{
ATRESP( atHandle, 0, 0, (char *)"*TDTR=<op>[,<gain>,<freq>]");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT*TDTR= */
{
int option;
int txRxGain;
char txRxGainStr[TEL_AT_TDTR_TX_RX_GAIN_STR_LEN_MAX + ATCI_NULL_TERMINATOR_LENGTH] = {0};
INT16 txRxGainLen = 0;
int freq;
BOOL cmdValid = FALSE;
if ( getExtValue(parameter_values_p, 0, &option, TEL_AT_TDTR_OPTION_MIN, TEL_AT_TDTR_OPTION_MAX, TEL_AT_TDTR_OPTION_DEFAULT) == TRUE )
{
int val_tbl[TEL_AT_TDTR_OPTION_MAX - TEL_AT_TDTR_OPTION_MIN + 1][3] = {
{TEL_AT_TDTR_TX_GAIN_MIN, TEL_AT_TDTR_TX_GAIN_MAX, TEL_AT_TDTR_TX_GAIN_DEFAULT},
{TEL_AT_TDTR_RX_GAIN_MIN, TEL_AT_TDTR_RX_GAIN_MAX, TEL_AT_TDTR_RX_GAIN_DEFAULT},
{INT_MIN, INT_MAX, 0}
};
if ( getExtString(parameter_values_p, 1, (CHAR *)txRxGainStr, TEL_AT_TDTR_TX_RX_GAIN_STR_LEN_MAX, &txRxGainLen, NULL) == TRUE )
{
if(txRxGainLen)
txRxGain = atoi(txRxGainStr);
else
txRxGain = val_tbl[option - TEL_AT_TDTR_OPTION_MIN][2];
if(txRxGain >= val_tbl[option - TEL_AT_TDTR_OPTION_MIN][0] && txRxGain <= val_tbl[option - TEL_AT_TDTR_OPTION_MIN][1])
{
if ( getExtValue(parameter_values_p, 2, &freq, TEL_AT_TDTR_FREQ_RANGE1_MIN, TEL_AT_TDTR_FREQ_RANGE2_MAX, TEL_AT_TDTR_FREQ_DEFAULT) == TRUE )
{
if(freq > TEL_AT_TDTR_FREQ_RANGE1_MAX && freq < TEL_AT_TDTR_FREQ_RANGE2_MIN)
cmdValid = FALSE;
else
cmdValid = TRUE;
}
}
}
}
if (cmdValid == TRUE)
{
ret = DEV_SetTdModeTxRxReq(atHandle, (CiDevTdTxRxOption)option, (INT16)txRxGain, (UINT16)freq);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*TDTR? */
case TEL_EXT_ACTION_CMD: /* AT*TDTR */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
BOOL checkArfcnValue(int gsmBandMode, int arfcn)
{
/* refer to 3GPP TS 45005 */
BOOL ret = FALSE;
if(gsmBandMode & (1 << CI_DEV_PGSM_900))
{
ret |= (arfcn >= 1 && arfcn <= 124);
}
if(gsmBandMode & (1 << CI_DEV_DCS_GSM_1800))
{
ret |= (arfcn >= 512 && arfcn < 885);
}
if(gsmBandMode & (1 << CI_DEV_PCS_GSM_1900))
{
ret |= (arfcn >= 512 && arfcn <= 810);
}
if(gsmBandMode & (1 << CI_DEV_EGSM_900))
{
ret |= ((arfcn >= 0 && arfcn <= 124) || (arfcn >= 975 && arfcn <= 1023));
}
if(gsmBandMode & (1 << CI_DEV_GSM_450))
{
ret |= (arfcn >= 259 && arfcn <= 293);
}
if(gsmBandMode & (1 << CI_DEV_GSM_480))
{
ret |= (arfcn >= 306 && arfcn <= 340);
}
if(gsmBandMode & (1 << CI_DEV_GSM_850))
{
ret |= (arfcn >= 128 && arfcn <= 251);
}
return ret;
}
/************************************************************************************
* F@: ciGSMTR - GLOBAL API for AT*GSMTR command
*
*/
RETURNCODE_T ciGSMTR( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciGSMTR, "ciGSMTR: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT*GSMTR=? */
{
ATRESP( atHandle, 0, 0, (char *)"*GSMTR=<op>[,<band>,<arfcn>,<afcDac>[,<txRampScale>,<rxGainCode>]]");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT*GSMTR= */
{
int option;
int gsmBandMode;
int arfcn;
int afcDac;
int txRampScale;
int rxGainCode;
BOOL cmdValid = FALSE;
if ( getExtValue(parameter_values_p, 0, &option, TEL_AT_GSMTR_OPTION_MIN, TEL_AT_GSMTR_OPTION_MAX, TEL_AT_GSMTR_OPTION_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 1, &gsmBandMode, TEL_AT_GSMTR_BAND_MODE_MIN, TEL_AT_GSMTR_BAND_MODE_MAX, TEL_AT_GSMTR_BAND_MODE_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 2, &arfcn, TEL_AT_GSMTR_ARFCN_MIN, TEL_AT_GSMTR_ARFCN_MAX, TEL_AT_GSMTR_ARFCN_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 3, &afcDac, TEL_AT_GSMTR_AFCDAC_MIN, TEL_AT_GSMTR_AFCDAC_MAX, TEL_AT_GSMTR_AFCDAC_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 4, &txRampScale, TEL_AT_GSMTR_TXRAMP_SCALE_MIN, TEL_AT_GSMTR_TXRAMP_SCALE_MAX, TEL_AT_GSMTR_TXRAMP_SCALE_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 5, &rxGainCode, TEL_AT_GSMTR_RXGAIN_CODE_MIN, TEL_AT_GSMTR_RXGAIN_CODE_MAX, TEL_AT_GSMTR_RXGAIN_CODE_DEFAULT) == TRUE )
{
if((option == CI_DEV_GSM_TX_RX_STOP) || checkArfcnValue(gsmBandMode, arfcn))
cmdValid = TRUE;
}
}
}
}
}
}
if (cmdValid == TRUE)
{
ret = DEV_SetGsmModeTxRxReq(atHandle, (CiDevGsmTxRxOption)option, (UINT8)gsmBandMode,
(UINT16)arfcn, (UINT32)afcDac, (UINT32)txRampScale, (UINT32)rxGainCode);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*GSMTR? */
case TEL_EXT_ACTION_CMD: /* AT*GSMTR */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#if defined(ATCMD_UNIFY_CI) || defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
int commtrMode = 0;
RETURNCODE_T ciCOMMTR( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciCOMMTR, "%s: atHandle = %d.\n", __FUNCTION__, atHandle);
switch ( op )
{
case TEL_EXT_SET_CMD: /* AT*COMMTR= */
{
int mode = 0;
int option = 0;
int band = 0;
char powerStr[8] = {0};
INT16 powerStr_length = 0;
int arfcn =0;
int slot = 0;
int bandwidth=0;
int cmdValid = 0;
if ( getExtValue(parameter_values_p, 0, &mode, TEL_AT_COMMTR_1_MODE_MIN, TEL_AT_COMMTR_1_MODE_MAX, TEL_AT_COMMTR_1_MODE_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 1, &option, TEL_AT_COMMTR_2_OPTION_MIN, TEL_AT_COMMTR_2_OPTION_MAX, TEL_AT_COMMTR_2_OPTION_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 2, &band, TEL_AT_COMMTR_3_BAND_MIN, TEL_AT_COMMTR_3_BAND_MAX, TEL_AT_COMMTR_3_BAND_DEFAULT) == TRUE )
{
if ( getExtString(parameter_values_p, 3, powerStr, TEL_AT_COMMTR_4_POWER_STR_MAX_LEN, &powerStr_length, TEL_AT_COMMTR_4_POWER_STR_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 4, &arfcn, TEL_AT_COMMTR_5_ARFCN_MIN, TEL_AT_COMMTR_5_ARFCN_MAX, TEL_AT_COMMTR_5_ARFCN_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 5, &bandwidth, TEL_AT_COMMTR_6_BANDWIDTH_MIN, TEL_AT_COMMTR_6_BANDWIDTH_MAX, TEL_AT_COMMTR_6_BANDWIDTH_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 6, &slot, TEL_AT_COMMTR_7_SLOT_MIN, TEL_AT_COMMTR_7_SLOT_MAX, TEL_AT_COMMTR_7_SLOT_DEFAULT) == TRUE )
{
DBGMSG(ciCOMMTR1, "ciCOMMTR:mode is %d, option is %d, band is %d, power is %s, arfcn is %d, bandwidth is %d, slot is %d", mode, option, band, powerStr, arfcn, bandwidth, slot);
cmdValid = 1;
commtrMode = mode;
}
}
}
}
}
}
}
if(cmdValid)
{
if((mode == CI_DEV_EM_NETWORK_GSM) || (mode == CI_DEV_EM_NETWORK_UMTS) || ((mode == CI_DEV_EM_NETWORK_LTE) && (((band > 0) && (band <= 8)) || (band == 17)|| (band == 20)|| (band == 28) ||
(band == 34) || ((band >= 38) && (band <= 41)) || (band == 65) || (band == 66) || (band == 68) || ((band >= 70) && (band <= 74))))
#if defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
|| (mode == CI_DEV_EM_NETWORK_NR)
#endif
)
{
CiDevPrimSetNstTxRxReq *setNstTxRxReq=NULL;
setNstTxRxReq = (CiDevPrimSetNstTxRxReq *)utlCalloc(1, sizeof(CiDevPrimSetNstTxRxReq));
if (setNstTxRxReq == NULL)
return CIRC_FAIL;
setNstTxRxReq->networkMode = mode;
setNstTxRxReq->option = option;
setNstTxRxReq->band = band;
setNstTxRxReq->power = (INT16)atoi(powerStr);
DBGMSG(ciCOMMTR2, "ciCOMMTR: power is %s %d %d", powerStr, atoi(powerStr), setNstTxRxReq->power);
setNstTxRxReq->arfcn = arfcn;
setNstTxRxReq->bandwidth= bandwidth;
setNstTxRxReq->slot = slot;
ret = DEV_SetCommTxRxReq(atHandle, setNstTxRxReq);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
case TEL_EXT_GET_CMD: /* AT*COMMTR? */
case TEL_EXT_ACTION_CMD: /* AT*COMMTR */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
/************************************************************************************
* F@: ciTGCTRL - GLOBAL API for AT*TGCTRL command
*
*/
RETURNCODE_T ciTGCTRL( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciTGCTRL, "ciTGCTRL: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT*TGCTRL=? */
{
ATRESP( atHandle, 0, 0, (char *)"*TGCTRL=<nw>,<op>,<value>[,<addr>]");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT*TGCTRL= */
{
int network = 0;
int mode = 0;
int regValue = 0;
int addrReg = 0;
BOOL cmdValid = FALSE;
if ( getExtValue(parameter_values_p, 0, &network, TEL_AT_TGCTRL_NETWORK_MIN, TEL_AT_TGCTRL_NETWORK_MAX, TEL_AT_TGCTRL_NETWORK_DEFAULT) == TRUE )
{
int val_tbl[TEL_AT_TGCTRL_NETWORK_MAX-TEL_AT_TGCTRL_NETWORK_MIN+1][3] = {
{TEL_AT_TGCTRL_TD_OPTION_MIN, TEL_AT_TGCTRL_TD_OPTION_MAX, TEL_AT_TGCTRL_TD_OPTION_DEFAULT},
{TEL_AT_TGCTRL_GSM_OPTION_MIN, TEL_AT_TGCTRL_GSM_OPTION_MAX, TEL_AT_TGCTRL_GSM_OPTION_DEFAULT},
};
if ( getExtValue(parameter_values_p, 1, &mode, val_tbl[network-TEL_AT_TGCTRL_NETWORK_MIN][0], val_tbl[network-TEL_AT_TGCTRL_NETWORK_MIN][1], val_tbl[network-TEL_AT_TGCTRL_NETWORK_MIN][2]) == TRUE )
{
if ( getExtValue(parameter_values_p, 2, &regValue, INT_MIN, INT_MAX, 0) == TRUE )
{
if ( getExtValue(parameter_values_p, 3, &addrReg, TEL_AT_TGCTRL_GSM_REG_ADDR_MIN, TEL_AT_TGCTRL_GSM_REG_ADDR_MAX, TEL_AT_TGCTRL_GSM_REG_ADDR_DEFAULT) == TRUE )
{
cmdValid = TRUE;
}
}
}
}
if (cmdValid == TRUE)
{
if(network == TEL_AT_TGCTRL_NETWORK_TD) /* TD network */
{
ret = DEV_SetTdModeLoopbackReq(atHandle, (UINT32)regValue);
}
else /* GSM network */
{
// CI_DEV_PRIM_SET_GSM_CONTROL_INTERFACE_REQ/CNF is not supported by DigRF
// ret = DEV_SetGsmControlInterfaceReq(atHandle, (CiDevGsmControlMode)mode, (UINT16)addrReg, (UINT16)regValue);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*TGCTRL? */
case TEL_EXT_ACTION_CMD: /* AT*TGCTRL */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciGSMTR - GLOBAL API for AT*WBTR command
*
*/
RETURNCODE_T ciWBTR( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciWBTR, "ciWBTR: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_SET_CMD: /* AT*WBTR= */
{
int option, dlUarfcn, ulUarfcn, paMode, apcDac, afcDac;
CHAR afcDacStr[TEL_AT_WBTR_AFC_DAC_STR_MAX_LEN + ATCI_NULL_TERMINATOR_LENGTH];
INT16 afcDacStrLen;
BOOL cmdValid = FALSE;
if ( getExtValue(parameter_values_p, 0, &option, TEL_AT_WBTR_OPTION_MIN, TEL_AT_WBTR_OPTION_MAX, TEL_AT_WBTR_OPTION_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 1, &dlUarfcn, TEL_AT_WBTR_DL_UARFCN_MIN, TEL_AT_WBTR_DL_UARFCN_MAX, TEL_AT_WBTR_DL_UARFCN_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 2, &ulUarfcn, TEL_AT_WBTR_UL_UARFCN_MIN, TEL_AT_WBTR_UL_UARFCN_MAX, TEL_AT_WBTR_UL_UARFCN_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 3, &paMode, TEL_AT_WBTR_PA_MODE_MIN, TEL_AT_WBTR_PA_MODE_MAX, TEL_AT_WBTR_PA_MODE_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 4, &apcDac, TEL_AT_WBTR_APC_DAC_MIN, TEL_AT_WBTR_APC_DAC_MAX, TEL_AT_WBTR_APC_DAC_DEFAULT) == TRUE )
{
if ( getExtString(parameter_values_p, 5, afcDacStr, TEL_AT_WBTR_AFC_DAC_STR_MAX_LEN, &afcDacStrLen, (CHAR *)TEL_AT_WBTR_AFC_DAC_DEFAULT ) == TRUE )
{
afcDac = atoi((char *)afcDacStr);
if(afcDac >= TEL_AT_WBTR_AFC_DAC_MIN && afcDac <= TEL_AT_WBTR_AFC_DAC_MAX)
{
cmdValid = TRUE;
}
}
}
}
}
}
}
if (cmdValid == TRUE)
{
ret = DEV_SetWcdmaModeTxRxReq(atHandle, (CiDevGsmTxRxOption)option, (UINT16)dlUarfcn,
(UINT16)ulUarfcn, (UINT8)paMode, (UINT16)apcDac, (INT16)afcDac);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
UINT16 EarfcnPro(UINT32 Earfcn)
{
UINT16 newEarfcn;
if((Earfcn >= 65536) && (Earfcn <= 69465)) //band65-band74 DL
{
//58000 - 61929
newEarfcn = Earfcn - 7536;
}
else if((Earfcn >= 131072) && (Earfcn <= 132671)) //band65 band66 UL
{
//58000 - 59599
newEarfcn = Earfcn - 73072;
}
else if((Earfcn >= 132672) && (Earfcn <= 132971)) //band68 UL
{
//60000 - 60299
newEarfcn = Earfcn - 72672;
}
else if((Earfcn >= 132972) && (Earfcn <= 133121)) //band70 UL
{
//60800 - 60949
newEarfcn = Earfcn - 72172;
}
else if((Earfcn >= 133122) && (Earfcn <= 134001)) //band71 - band74
{
//61050 - 61929
newEarfcn = Earfcn - 72072;
}
else
newEarfcn = Earfcn;
return newEarfcn;
}
UINT8 ltepower_flag=0;
UINT8 ltepower_flag_1=0;
/************************************************************************************
* F@: ciLTEMaxPower - GLOBAL API for AT+LTEPOWER command
*
*/
RETURNCODE_T ciLTEMaxPower( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
UINT8 *p_ltepower_flag;
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciLTEMaxPower,"%s: atHandle = %d.\n", __FUNCTION__, atHandle);
if (!GET_SIM1_FLAG(atHandle))
{
p_ltepower_flag = &ltepower_flag;
}
else
{
p_ltepower_flag = &ltepower_flag_1;
}
/*
* process operation
*/
/*mischecked by klocwork*/
/*klocwork[Inconsistent Case Labels]*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT+LTEPOWER=? */
{
ATRESP( atHandle, 0, 0, (char *)"+LTEPOWER=<op>,<channel>,<power>");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT+LTEPOWER= */
{
int option=0;
int channel=0;
int power=0;
INT16 txpower = 0;
UINT16 freq = 19500;
//only support TX in AT+LTEPOWER
if ( getExtValue(parameter_values_p, 0, &option, TEL_AT_LTEPOWER_OPTION_MIN, TEL_AT_LTEPOWER_OPTION_MIN, TEL_AT_LTEPOWER_OPTION_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 1, &channel, TEL_AT_LTEPOWER_CHANNEL_MIN, TEL_AT_LTEPOWER_CHANNEL_MAX, TEL_AT_LTEPOWER_CHANNEL_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 2, &power, TEL_AT_LTEPOWER_POWER_MIN, TEL_AT_LTEPOWER_POWER_MAX, TEL_AT_LTEPOWER_POWER_DEFAULT) == TRUE )
{
if(option == 1)
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_OK,0,(char*)"NG");
break;
}
if(((power == 0) || (power == 1) || (power == 9)) && (((channel > 0) && (channel <= 8)) || (channel == 17)|| (channel == 20)|| (channel == 28) ||
(channel == 34) || ((channel >= 38) && (channel <= 41)) || (channel == 65) || (channel == 66) || (channel == 68) || ((channel >= 70) && (channel <= 74))))
{
if((option == 0) && (channel == 1) && (power == 9)) //turn off TX
{
*p_ltepower_flag=1;
ret = DEV_SetLTEModeTxRxReq(atHandle, 2, 0, 0, 0);
}
else
{
if(power == 0) //maxpower
txpower = 1900;
else //10dBm
txpower = 1700;
switch(channel)
{
case 1:
freq = 18300;
break;
case 2:
freq = 18900;
break;
case 3:
freq = 19500;
break;
case 4:
freq = 20175;
break;
case 5:
freq = 20525;
break;
case 6:
freq = 20700;
break;
case 7:
freq = 21100;
break;
case 8:
freq = 21625;
break;
case 17:
freq = 23790;
break;
case 20:
freq = 24300;
break;
case 28:
freq = 27435;
break;
case 34:
freq = 36275;
break;
case 38:
freq = 38000;
break;
case 39:
freq = 38450;
break;
case 40:
freq = 39150;
break;
case 41:
freq = 40620;
break;
case 65:
freq = EarfcnPro(131522);
break;
case 66:
freq = EarfcnPro(132322);
break;
case 68:
freq = EarfcnPro(132822);
break;
case 70:
freq = EarfcnPro(133046);
break;
case 71:
freq = EarfcnPro(133296);
break;
case 72:
freq = EarfcnPro(133496);
break;
case 73:
freq = EarfcnPro(133546);
break;
case 74:
freq = EarfcnPro(133786);
break;
}
*p_ltepower_flag=1;
ret = DEV_SetLTEModeTxRxReq(atHandle, option, freq, txpower,0);
}
}
else
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_OK,0,(char*)"NG");
}
}
else
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_OK,0,(char*)"NG");
}
}
else
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_OK,0,(char*)"NG");
}
}
else
{
//DBGMSG(ciLTEMaxPower,"%s: ltemaxpower error.\n", __FUNCTION__);
ret = ATRESP(atHandle,ATCI_RESULT_CODE_OK,0,(char*)"NG");
}
break;
}
case TEL_EXT_GET_CMD: /* AT+LTEPOWER? */
case TEL_EXT_ACTION_CMD: /* AT+LTEPOWER */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
RETURNCODE_T ciLTETR( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
UINT8 *p_ltepower_flag;
*xid_p = atHandle;
//DBGMSG(ciLTETR,"%s: atHandle = %d.\n", __FUNCTION__, atHandle);
if (!GET_SIM1_FLAG(atHandle))
{
p_ltepower_flag = &ltepower_flag;
}
else
{
p_ltepower_flag = &ltepower_flag_1;
}
*xid_p = atHandle;
//DBGMSG(ciLTETR,"%s: atHandle = %d.\n", __FUNCTION__, atHandle);
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT*LTETR=? */
{
ATRESP( atHandle, 0, 0, (char *)"*LTETR=<op>,<channel>,<power>,<bandwidth>");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT*LTETR= */
{
int option=0;
int channel=0;
int power=0;
int rxpower_target =0;
INT16 txpower = 0;
UINT16 freq = 19500;
int bandwidth=0;
if ( getExtValue(parameter_values_p, 0, &option, TEL_AT_LTEPOWER_OPTION_MIN, TEL_AT_LTEPOWER_OPTION_MAX, TEL_AT_LTEPOWER_OPTION_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 1, &channel, TEL_AT_LTEPOWER_CHANNEL_MIN, TEL_AT_LTEPOWER_CHANNEL_MAX, TEL_AT_LTEPOWER_CHANNEL_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 2, &power, TEL_AT_LTEPOWER_POWER_MIN, TEL_AT_LTEPOWER_POWER_MAX, TEL_AT_LTEPOWER_POWER_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 3, &bandwidth, TEL_AT_LTEPOWER_BANDWIDTH_MIN, TEL_AT_LTEPOWER_BANDWIDTH_MAX, TEL_AT_LTEPOWER_BANDWIDTH_DEFAULT) == TRUE )
{
if(((power == 0) || (power == 1) || (power == 9)) && (((channel > 0) && (channel <= 8)) || (channel == 17)|| (channel == 20)|| (channel == 28) ||
(channel == 34) || ((channel >= 38) && (channel <= 41)) || (channel == 65) || (channel == 66) || (channel == 68) || ((channel >= 70) && (channel <= 74))))
{
//DBGMSG(ciLTETR,"ciLTETR:option is %d, channel is %d, power is %d, bandwidth is %d", option,channel, power,bandwidth);
if((option == 0) && (channel == 1) && (power == 9)) //turn off TX or RX
{
*p_ltepower_flag=1;
ret = DEV_SetLTEModeTxRxReq(atHandle, 2, 0, 0, 0);
}
else if (option == 0) //start TX test
{
if(power == 0) //maxpower
txpower = 1900;
else //10dBm
txpower = 1700;
switch(channel)
{
case 1:
freq = 18300;
break;
case 2:
freq = 18900;
break;
case 3:
freq = 19500;
break;
case 4:
freq = 20175;
break;
case 5:
freq = 20525;
break;
case 6:
freq = 20700;
break;
case 7:
freq = 21100;
break;
case 8:
freq = 21625;
break;
case 17:
freq = 23790;
break;
case 20:
freq = 24300;
break;
case 28:
freq = 27435;
break;
case 34:
freq = 36275;
break;
case 38:
freq = 38000;
break;
case 39:
freq = 38450;
break;
case 40:
freq = 39150;
break;
case 41:
freq = 40620;
break;
case 65:
freq = EarfcnPro(131522);
break;
case 66:
freq = EarfcnPro(132322);
break;
case 68:
freq = EarfcnPro(132822);
break;
case 70:
freq = EarfcnPro(133046);
break;
case 71:
freq = EarfcnPro(133296);
break;
case 72:
freq = EarfcnPro(133496);
break;
case 73:
freq = EarfcnPro(133546);
break;
case 74:
freq = EarfcnPro(133786);
break;
}
*p_ltepower_flag=1;
//DBGMSG(ciLTETR,"ciLTETR tx: freq is %d, txpower is %d", freq, txpower);
ret = DEV_SetLTEModeTxRxReq(atHandle, (CiDevLteTxRxOption)option, (UINT16)freq, (INT16)txpower,0);
}
else if (option == 1) //start RX test
{
if(power == 0)
rxpower_target = -800;
else
rxpower_target = -960;
switch(channel)
{
case 1:
freq = 300; //tx 18300
break;
case 2:
freq = 900; //tx 18900
break;
case 3:
freq = 1575; //tx 19500;
break;
case 4:
freq = 2175; //tx 20175;
break;
case 5:
freq = 2525; //tx 20525;
break;
case 6:
freq = 2700; //tx 20700;
break;
case 7:
freq = 3100; //tx 21100;
break;
case 8:
freq = 3625; //tx 21625;
break;
case 17:
freq = 5790; //tx 23790;
break;
case 20:
freq = 6300; //tx 24300;
break;
case 28:
freq = 9435; //27435;
break;
case 34:
freq = 36275; //tx 36275;
break;
case 38:
freq = 38000;
break;
case 39:
freq = 38450;
break;
case 40:
freq = 39150;
break;
case 41:
freq = 40620;
break;
case 65:
freq = EarfcnPro(65986);
break;
case 66:
freq = EarfcnPro(66886);
break;
case 68:
freq = EarfcnPro(67686);
break;
case 70:
freq = EarfcnPro(68460);
break;
case 71:
freq = EarfcnPro(68760);
break;
case 72:
freq = EarfcnPro(68960);
break;
case 73:
freq = EarfcnPro(69010);
break;
case 74:
freq = EarfcnPro(69250);
break;
}
*p_ltepower_flag=1;
//DBGMSG(ciLTETR,"ciLTETR rx: freq is %d, rx target power is %d,bandwidth is %d", freq, rxpower_target, bandwidth);
ret = DEV_SetLTEModeTxRxReq(atHandle, (CiDevLteTxRxOption)option, (UINT16)freq, (INT16)rxpower_target, (UINT8)bandwidth);
}
else if (option == 2) //turn off RX/TX
{
*p_ltepower_flag=1;
ret = DEV_SetLTEModeTxRxReq(atHandle, 2, 0, 0, 0);
}
}
}
else
ret = ATRESP(atHandle,ATCI_RESULT_CODE_SUPPRESS,0,(char*)"NA1");
}
else
ret = ATRESP(atHandle,ATCI_RESULT_CODE_SUPPRESS,0,(char*)"NA2");
}
else
ret = ATRESP(atHandle,ATCI_RESULT_CODE_SUPPRESS,0,(char*)"NA3");
}
else
ret = ATRESP(atHandle,ATCI_RESULT_CODE_SUPPRESS,0,(char*)"NA4");
break;
}
case TEL_EXT_GET_CMD: /* AT+LTETR? */
case TEL_EXT_ACTION_CMD: /* AT+LTETR */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
static int lastMode = 0;
/************************************************************************************
* F@: ciGsmWcdmaMaxPower - GLOBAL API for AT*MAXPOWER command
*
*/
RETURNCODE_T ciGsmWcdmaMaxPower( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciGsmWcdmaMaxPower,"%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT*MAXPOWER=? */
{
ATRESP( atHandle, 0, 0, (char *)"+MAXPOWER=<op>,<para1>,<para2>");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT*MAXPOWER= */
{
int option;
int Para1;
int Para2;
if ( getExtValue(parameter_values_p, 0, &option, 0, 0, 0) == TRUE )
{
if ( getExtValue(parameter_values_p, 1, &Para1, 0, 9, 0) == TRUE )
{
if ( getExtValue(parameter_values_p, 2, &Para2, 0, 9, 0) == TRUE )
{
if((Para2 == 0) || (Para2 == 1) || (Para2 == 9))
{
#if 0
if(PlatformIsLwgVersion() == TRUE) //WCDMA
{
SetCfunValue(0);
OSATaskSleep(200);
}
CurOp = option;
#endif
if((option == 0) && (Para1 == 9) && (Para2 == 9)) //turn off TX
{
if(lastMode == 1) //UMTS
ret = DEV_SetWcdmaModeTxRxReq(atHandle, 2, 0, 0, 0, 0, 0);
else //GSM
ret = DEV_SetGsmModeTxRxReq(atHandle, 3, 0, 0, 0, 0, 0);
}
else if(option == 0)
{
switch(Para1)
{
case 0: //GSM900
lastMode = 0;
if(!Para2)
ret = DEV_SetGsmModeTxRxReq(atHandle, 0, 8, 37, 13500, 920, 20); //max power
else
ret = DEV_SetGsmModeTxRxReq(atHandle, 0, 8, 37, 13500, 200, 20); //10dBm
break;
case 1: //GSM1800
lastMode = 0;
if(!Para2)
ret = DEV_SetGsmModeTxRxReq(atHandle, 0, 2, 698, 13500, 800, 20); //max power
else
ret = DEV_SetGsmModeTxRxReq(atHandle, 0, 2, 698, 13500, 220, 20); //10dBm
break;
case 2: //GSM1900
lastMode = 0;
if(!Para2)
ret = DEV_SetGsmModeTxRxReq(atHandle, 0, 4, 661, 13500, 800, 20); //max power
else
ret = DEV_SetGsmModeTxRxReq(atHandle, 0, 4, 661, 13500, 220, 20); //10dBm
break;
case 3: //GSM850
lastMode = 0;
if(!Para2)
ret = DEV_SetGsmModeTxRxReq(atHandle, 0, 64, 128, 13500, 600, 20); //max power
else
ret = DEV_SetGsmModeTxRxReq(atHandle, 0, 64, 128, 13500, 200, 20); //10dBm
break;
case 4: //WCDMA band1
lastMode = 1;
if(!Para2)
ret = DEV_SetWcdmaModeTxRxReq(atHandle, 0, 10700, 9750, 2, 2000, 13500); //max power
else
ret = DEV_SetWcdmaModeTxRxReq(atHandle, 0, 10700, 9750, 0, 1800, 13500); //10dBm
break;
case 5: //WCDMA band2
lastMode = 1;
if(!Para2)
ret = DEV_SetWcdmaModeTxRxReq(atHandle, 0, 9800, 9400, 2, 2000, 13500); //max power
else
ret = DEV_SetWcdmaModeTxRxReq(atHandle, 0, 9800, 9400, 0, 1800, 13500); //10dBm
break;
case 7: //WCDMA band5
lastMode = 1;
if(!Para2)
ret = DEV_SetWcdmaModeTxRxReq(atHandle, 0, 4407, 4182, 2, 2000, 13500); //max power
else
ret = DEV_SetWcdmaModeTxRxReq(atHandle, 0, 4407, 4182, 0, 1800, 13500); //10dBm
break;
case 8: //WCDMA band8
lastMode = 1;
if(!Para2)
ret = DEV_SetWcdmaModeTxRxReq(atHandle, 0, 3013, 2788, 2, 2000, 13500); //max power
else
ret = DEV_SetWcdmaModeTxRxReq(atHandle, 0, 3013, 2788, 1, 1800, 13500); //10dBm
break;
default:
ret = ATRESP(atHandle,ATCI_RESULT_CODE_SUPPRESS,0,(char*)"NA");
}
}
}
else
ret = ATRESP(atHandle,ATCI_RESULT_CODE_SUPPRESS,0,(char*)"NA");
}
else
ret = ATRESP(atHandle,ATCI_RESULT_CODE_SUPPRESS,0,(char*)"NA");
}
else
ret = ATRESP(atHandle,ATCI_RESULT_CODE_SUPPRESS,0,(char*)"NA");
}
else
ret = ATRESP(atHandle,ATCI_RESULT_CODE_SUPPRESS,0,(char*)"NA");
break;
}
case TEL_EXT_GET_CMD: /* AT*MAXPOWER? */
case TEL_EXT_ACTION_CMD: /* AT*MAXPOWER */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
/************************************************************************************
* F@: ciTGCTRL - GLOBAL API for AT^HVER command
*
*/
RETURNCODE_T ciGetHVER( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
UNUSEDPARAM(parameter_values_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciGetHVER, "ciGetHVER: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_ACTION_CMD: /* AT^HVER */
{
char hardwareVerBuf[TEL_AT_HVER_MAX_HARDWARE_VERSION_LEN + ATCI_NULL_TERMINATOR_LENGTH];
char buf[50];
int getHVertRet;
if ( (getHVertRet = get_hardwareVersion(hardwareVerBuf, sizeof(hardwareVerBuf))) > 0)
{
//DBGMSG(ciGetHVER1, "ciGetHVER: hardware version = %s\n", hardwareVerBuf);
sprintf(buf, "^HVER:\"%s\"\r\n", hardwareVerBuf);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, buf);
}
else
{
WARNMSG(ciGetHVER2, "ciGetHVER: Can not get hardware version, ret = %d\n", getHVertRet);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
}
break;
}
case TEL_EXT_SET_CMD: /* AT^HVER= */
case TEL_EXT_GET_CMD: /* AT^HVER? */
case TEL_EXT_TEST_CMD: /* AT^HVER=?*/
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#ifdef OPHONE
/************************************************************************************
* F@: ciDCTS - GLOBAL API for AT^DCTS command
*
*/
RETURNCODE_T ciDCTS( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciDCTS, "ciDCTS: atHandle = %d.\n", atHandle);
#ifndef ATCMD_1802S_CI
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT^DCTS=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"^DCTS: (0),(16,96)");
break;
}
case TEL_EXT_SET_CMD: /* AT^DCTS= */
{
int option = 0;
int mode = 0;
BOOL cmdValid = FALSE;
if ( getExtValue(parameter_values_p, 0, &option, TEL_AT_DCTS_OPTION_MIN, TEL_AT_DCTS_OPTION_MAX, TEL_AT_DCTS_OPTION_DEFAULT) == TRUE )
{
if ( (getExtValue(parameter_values_p, 1, &mode, TEL_AT_DCTS_MODE_MIN, TEL_AT_DCTS_MODE_MAX, TEL_AT_DCTS_MODE_DEFAULT) == TRUE)
&& ((mode == CI_DEV_NW_MONIOTR_NORMAL) || (mode == CI_DEV_NW_MONIOTR_DETECT)))
{
cmdValid = TRUE;
}
}
if (cmdValid == TRUE)
{
ret = DEV_SetNetWorkMonitorOptReq(atHandle, (CiBoolean)option, (CiDevNwMonitorMode)mode);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT^DCTS? */
{
ret = DEV_GetNetWorkMonitorOptReq(atHandle);
break;
}
case TEL_EXT_ACTION_CMD: /* AT^DCTS */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
#endif
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciDCTS - GLOBAL API for AT^DEELS command
*
*/
RETURNCODE_T ciDEELS( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciDEELS, "ciDEELS: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT^DEELS=? */
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"^DEELS: (0,1)");
break;
}
case TEL_EXT_SET_CMD: /* AT^DEELS= */
{
int option = 0;
BOOL cmdValid = FALSE;
if ( getExtValue(parameter_values_p, 0, &option, TEL_AT_DEELS_OPTION_MIN, TEL_AT_DEELS_OPTION_MAX, TEL_AT_DEELS_OPTION_DEFAULT) == TRUE )
{
cmdValid = TRUE;
}
if (cmdValid == TRUE)
{
ret = DEV_SetProtocolStatusConfigReq(atHandle, (CiBoolean)option);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT^DEELS? */
{
ret = DEV_GetProtocolStatusConfigReq(atHandle);
break;
}
case TEL_EXT_ACTION_CMD: /* AT^DEELS */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciDCTS - GLOBAL API for AT^DEVEI command
*
*/
RETURNCODE_T ciDEVEI( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciDEVEI, "ciDEVEI: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT^DEVEI=? */
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"^DEVEI: (0,1)");
break;
}
case TEL_EXT_SET_CMD: /* AT^DEVEI= */
{
int option = 0;
BOOL cmdValid = FALSE;
if ( getExtValue(parameter_values_p, 0, &option, TEL_AT_DEVEI_OPTION_MIN, TEL_AT_DEVEI_OPTION_MAX, TEL_AT_DEVEI_OPTION_DEFAULT) == TRUE )
{
cmdValid = TRUE;
}
if (cmdValid == TRUE)
{
ret = DEV_SetEventIndConfigReq(atHandle, (CiBoolean)option);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT^DEVEI? */
{
ret = DEV_GetEventIndConfigReq(atHandle);
break;
}
case TEL_EXT_ACTION_CMD: /* AT^DEVEI */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciDCTS - GLOBAL API for AT^DNPR command
*
*/
RETURNCODE_T ciDNPR( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciDNPR, "ciDNPR: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT^DNPR=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"^DNPR: (0,1),(0,65535)");
break;
}
case TEL_EXT_SET_CMD: /* AT^DNPR= */
{
int option = 0;
int interval = 0;
BOOL cmdValid = FALSE;
if ( getExtValue(parameter_values_p, 0, &option, TEL_AT_DNPR_OPTION_MIN, TEL_AT_DNPR_OPTION_MAX, TEL_AT_DNPR_OPTION_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 1, &interval, TEL_AT_DNPR_INTERVAL_MIN, TEL_AT_DNPR_INTERVAL_MAX, TEL_AT_DNPR_INTERVAL_DEFAULT) == TRUE )
{
cmdValid = TRUE;
}
}
if (cmdValid == TRUE)
{
ret = DEV_SetWirelessParamConfigReq(atHandle, (CiBoolean)option, (UINT16)interval);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT^DNPR? */
{
ret = DEV_GetWirelessParamConfigReq(atHandle);
break;
}
case TEL_EXT_ACTION_CMD: /* AT^DNPR */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciDCTS - GLOBAL API for AT^DUSR command
*
*/
RETURNCODE_T ciDUSR( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciDUSR, "ciDUSR: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT^DUSR=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"^DUSR: (0,1),(0,1)");
break;
}
case TEL_EXT_SET_CMD: /* AT^DUSR= */
{
int option = 0;
int mode = 0;
BOOL cmdValid = FALSE;
if ( getExtValue(parameter_values_p, 0, &option, TEL_AT_DUSR_OPTION_MIN, TEL_AT_DUSR_OPTION_MAX, TEL_AT_DUSR_OPTION_DEFAULT) == TRUE )
{
if ( getExtValue(parameter_values_p, 1, &mode, TEL_AT_DUSR_MODE_MIN, TEL_AT_DUSR_MODE_MAX, TEL_AT_DUSR_MODE_DEFAULT) == TRUE )
{
cmdValid = TRUE;
}
}
if (cmdValid == TRUE)
{
ret = DEV_SetSignalingReportConfigReq(atHandle, (CiBoolean)option, (CiBoolean)mode);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT^DUSR? */
{
ret = DEV_GetSignalingReportConfigReq(atHandle);
break;
}
case TEL_EXT_ACTION_CMD: /* AT^DUSR */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
/************************************************************************************
* F@: ciDCTS - GLOBAL API for AT*GRIP command
*
*/
RETURNCODE_T ciGRIP( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciGRIP, "ciGRIP: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_SET_CMD: /* AT*GRIP= */
{
int opt = 0;
int value = 0;
int networkMode = 0;
int band = 0;
BOOL cmdValid = FALSE;
#if defined(ATCMD_UNIFY_CI)
int bandwidth = 0;
#endif
if ( getExtValue(parameter_values_p, 0, &opt, 0, 255, 0) == TRUE )
{
if( getExtValue(parameter_values_p, 1, &value, 0, 255, 0)== TRUE )
{
if( getExtValue(parameter_values_p, 2, &networkMode, 0, 6, 6)== TRUE )
{
if( getExtValue(parameter_values_p, 3, &band, 0, 255, 255)== TRUE )
{
#if defined(ATCMD_UNIFY_CI)
if( getExtValue(parameter_values_p, 4, &bandwidth, 0, 6, 0)== TRUE )
{
cmdValid = TRUE;
DBGMSG(ciGRIP0, "ciGRIP: %d,%d,%d,%d,%d", opt, value, networkMode, band, bandwidth);
ret = DEV_SetPowerBackOffReq(atHandle, (UINT8)opt, (UINT8)value, (UINT8)networkMode, (UINT8)band, (UINT8)bandwidth);
}
#else
cmdValid = TRUE;
//DBGMSG(ciGRIP0, "ciGRIP: %d,%d,%d,%d", opt, value, networkMode, band);
ret = DEV_SetPowerBackOffReq(atHandle, (UINT8)opt, (UINT8)value, (UINT8)networkMode, (UINT8)band);
#endif
}
}
}
}
if(FALSE == cmdValid)
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciCGMR - GLOBAL API for AT*CGMR command
*
*/
RETURNCODE_T ciCGMR( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciCGMR, "ciCGMR: atHandle = %d.\n", atHandle);
char respbuf[MAX_INTERNALREVISION_ID_LENGTH + MAX_BUILDTIME_STR_LENGTH + 20];
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_ACTION_CMD: /* AT*CGMR */
{
sprintf(respbuf, "*CGMR: \"%s\",\"%s\"", internalRevisionId, buildTimeStr);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, respbuf);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
UINT8 comcfg_flag = 0;
BOOL set_COMCFG(UINT32 atHandle, const utlAtParameterValue_P2c parameter_values_p, BOOL *valid)
{
CiReturnCode ret = CIRC_FAIL;
int umtsWbAmr = 0;
int gsmWbAmr = 0;
int vendor = 0;
int manufacture = 0;
int lteCategory = 0;
int mutiSlotPowerProfile = 0;
int lteSMSOnly = 0;
int ecSupported = 0;
int epcoSupported = 0;
int hccpSupported = 0;
int mdrbSupported = 0;
int cpBackoff = 0;
int nslp = 0;
int eab = 0;
int rohc = 0;
int attachWoPdn = 0;
int attachWithImsi = 0;
ComConfig ComConfigData;
UINT8 *p_comcfg_flag;
p_comcfg_flag = &comcfg_flag;
if ( getExtValue(parameter_values_p, 1, &umtsWbAmr, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 2, &gsmWbAmr, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 3, &vendor, 0, 2047, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 4, &manufacture, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 5, &lteCategory, 1, 254, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 6, &mutiSlotPowerProfile, 1, 255, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 7, &lteSMSOnly, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 8, &ecSupported, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 9, &epcoSupported, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 10, &hccpSupported, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 11, &mdrbSupported, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 12, &cpBackoff, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 13, &nslp, 0, 3, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 14, &eab, 0, 3, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 15, &rohc, 0, 511, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 16, &attachWoPdn, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 17, &attachWithImsi, 0, 1, 65535) == TRUE )
{
*valid = TRUE;
*p_comcfg_flag = 1;
memset(&ComConfigData, 0 , sizeof(ComConfigData));
ComConfigData.umtsWbAmr = umtsWbAmr;
ComConfigData.gsmWbAmr = gsmWbAmr;
ComConfigData.vendor = vendor;
ComConfigData.manufacture = manufacture;
ComConfigData.lteCategory = lteCategory;
ComConfigData.mutiSlotPowerProfile = mutiSlotPowerProfile;
ComConfigData.lteSMSOnly = lteSMSOnly;
ComConfigData.ecSupported = ecSupported;
ComConfigData.epcoSupported = epcoSupported;
ComConfigData.hccpSupported = hccpSupported;
ComConfigData.mdrbSupported = mdrbSupported;
ComConfigData.cpBackoff = cpBackoff;
ComConfigData.nslp = nslp;
ComConfigData.eab = eab;
ComConfigData.rohc =rohc;
ComConfigData.attachWoPdn = attachWoPdn;
ComConfigData.attachWithImsi = attachWithImsi;
ret = DEV_SetComConfigReq(atHandle, &ComConfigData);
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
return ret;
}
BOOL set_COMCFG_v0001(UINT32 atHandle, const utlAtParameterValue_P2c parameter_values_p, BOOL *valid)
{
CiReturnCode ret = CIRC_FAIL;
int umtsWbAmr = 0;
int gsmWbAmr = 0;
int vendor = 0;
int manufacture = 0;
int lteCategory = 0;
int mutiSlotPowerProfile = 0;
int lteSMSOnly = 0;
int ecSupported = 0;
int epcoSupported = 0;
int hccpSupported = 0;
int mdrbSupported = 0;
int cpBackoff = 0;
int nslp = 0;
int eab = 0;
int rohc = 0;
ComConfig ComConfigData;
UINT8 *p_comcfg_flag;
p_comcfg_flag = &comcfg_flag;
if ( getExtValue(parameter_values_p, 1, &umtsWbAmr, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 2, &gsmWbAmr, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 3, &vendor, 0, 2047, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 4, &manufacture, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 5, &lteCategory, 1, 254, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 6, &mutiSlotPowerProfile, 1, 255, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 7, &lteSMSOnly, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 8, &ecSupported, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 9, &epcoSupported, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 10, &hccpSupported, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 11, &mdrbSupported, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 12, &cpBackoff, 0, 1, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 13, &nslp, 0, 3, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 14, &eab, 0, 3, 65535) == TRUE )
{
if ( getExtValue(parameter_values_p, 15, &rohc, 0, 511, 65535) == TRUE )
{
*valid = TRUE;
*p_comcfg_flag = 1;
memset(&ComConfigData, 0 , sizeof(ComConfigData));
ComConfigData.umtsWbAmr = umtsWbAmr;
ComConfigData.gsmWbAmr = gsmWbAmr;
ComConfigData.vendor = vendor;
ComConfigData.manufacture = manufacture;
ComConfigData.lteCategory = lteCategory;
ComConfigData.mutiSlotPowerProfile = mutiSlotPowerProfile;
ComConfigData.lteSMSOnly = lteSMSOnly;
ComConfigData.ecSupported = ecSupported;
ComConfigData.epcoSupported = epcoSupported;
ComConfigData.hccpSupported = hccpSupported;
ComConfigData.mdrbSupported = mdrbSupported;
ComConfigData.cpBackoff = cpBackoff;
ComConfigData.nslp = nslp;
ComConfigData.eab = eab;
ComConfigData.rohc =rohc;
ret = DEV_SetComConfigReq(atHandle, &ComConfigData);
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
return ret;
}
/************************************************************************************
* F@: ciCOMCFG - GLOBAL API for AT*COMCFG command
*
*/
RETURNCODE_T ciCOMCFG( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
UINT8 *p_comcfg_flag;
p_comcfg_flag = &comcfg_flag;
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciCOMCFG, "ciCOMCFG: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_SET_CMD: /* AT*COMCFG= */
{
int option = 0;
int mode = 0;
unsigned int tokens = 0;
BOOL cmdValid = FALSE;
if ( getExtValue(parameter_values_p, 0, &mode, 0, 1, 0) == TRUE )
{
/*get config*/
if(mode == 0)
{
if ( getExtUValue(parameter_values_p, 1, &tokens, 0, 0xFFFFFFFF, 0) == TRUE )
{
cmdValid = TRUE;
*p_comcfg_flag = 1;
ret = DEV_GetComConfigReq(atHandle, (UINT32)tokens);
}
}
/*set config*/
else
{
#if defined(ATCMD_UNIFY_CI)
if(devVersion > 0x0001)
ret = set_COMCFG(atHandle, parameter_values_p, &cmdValid);
else
ret = set_COMCFG_v0001(atHandle, parameter_values_p, &cmdValid);
#else
ret = set_COMCFG(atHandle, parameter_values_p, &cmdValid);
#endif
}
}
if (cmdValid != TRUE)
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#ifdef OPERATOR_VERIZON
/************************************************************************************
* F@: ciVZWRSRP - GLOBAL API for AT+VZWRSRP command
*
*/
RETURNCODE_T ciVZWRSRP( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciVZWRSRP, "ciVZWRSRP: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+VZWRSRP? */
{
ret = DEV_GetVZWRsrpReq(atHandle);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciVZWRSRQ - GLOBAL API for AT+VZWRSRQ command
*
*/
RETURNCODE_T ciVZWRSRQ( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciVZWRSRQ, "ciVZWRSRQ: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+VZWRSRQ? */
{
ret = DEV_GetVZWRsrqReq(atHandle);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
/************************************************************************************
* F@: ciL1Debug - GLOBAL API for GCF AT*L1DEBUG command
*
*/
RETURNCODE_T ciL1Debug( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
//UNUSEDPARAM(command_name_p)
//UNUSEDPARAM(num_parameters)
//UNUSEDPARAM(info_text_p)
//UNUSEDPARAM(xid_p)
//UNUSEDPARAM(arg_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
CHAR strBuf[TEL_AT_L1DEBUG_ADDRESS_STR_MAX_LEN + ATCI_NULL_TERMINATOR_LENGTH]={0};
INT16 addressLen = 0;
*xid_p = atHandle;
// INFOMSG(ciL1Debug1,"enter %s", __FUNCTION__);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT*L1DEBUG=? */
{
/* No CI primitive for this: print hard-coded reply */
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*L1DEBUG: <info>" );
break;
}
case TEL_EXT_SET_CMD: /* AT*L1DEBUG= */
{
if( getExtString( parameter_values_p, 0, strBuf, TEL_AT_L1DEBUG_ADDRESS_STR_MAX_LEN, &addressLen , (CHAR *)TEL_AT_L1DEBUG_ADDRESS_STR_DEFAULT) == TRUE )
{
//INFOMSG(ciL1Debug1,"%s: addressLen is %d", __FUNCTION__,addressLen);
if(addressLen!=0)
ret = Dev_L1Debug(atHandle, strBuf, addressLen);
}
break;
}
case TEL_EXT_GET_CMD:
default:
{
ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: atZIPPASS - GLOBAL API for GCF AT+ZIPPASS command
*
*/
RETURNCODE_T atZIPPASS( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
//UNUSEDPARAM(command_name_p)
//UNUSEDPARAM(num_parameters)
//UNUSEDPARAM(info_text_p)
//UNUSEDPARAM(xid_p)
//UNUSEDPARAM(arg_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
CHAR returnStr[20] = {0};
CHAR strbuff[64] = {0};
int ippass = 0;
*xid_p = atHandle;
// INFOMSG(ciL1Debug1,"enter %s", __FUNCTION__);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+ZIPPASS? */
{
memset(returnStr, 0, sizeof(returnStr));
executeShellCMD("uci get cmdline.PIPE 2>/dev/null", returnStr);
sprintf(strbuff, "+ZIPPASS: %d", memcmp(returnStr, "1", 1) == 0 ? 1 : 0);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, strbuff);
break;
}
case TEL_EXT_SET_CMD: /* AT+ZIPPASS= */
{
if(getExtValue(parameter_values_p, 0, &ippass, 0, 1, 0) == TRUE)
{
int rc;
ASR_flag tag;
rc = get_asr_flag(&tag);
if(rc < 0)
{
WARNMSG(ciACONFIG1, "read asr flag error\n");
}
else
{
tag.pipe[0] = PIPEID;
tag.pipe[1] = ippass;
rc = write_asr_flag(&tag);
}
sprintf(strbuff, "zippass.sh %d", ippass);
executeShellCMD(strbuff, returnStr);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, NULL, NULL);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_TEST_CMD: /* AT+ZIPPASS=? */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+ZIPPASS: <enable:0/1>" );
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#if defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI) || defined(ATCMD_UNIFY_CI)
/************************************************************************************
* F@: ciDspInfo - GLOBAL API for GCF AT*DSPINFO command
*
*/
RETURNCODE_T ciDspInfo( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
//UNUSEDPARAM(command_name_p)
//UNUSEDPARAM(num_parameters)
//UNUSEDPARAM(info_text_p)
//UNUSEDPARAM(xid_p)
//UNUSEDPARAM(arg_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
CHAR dataBuf[512]={0};
INT16 dataStrLen = 0;
int cmdID=0, NwMode=0;
*xid_p = atHandle;
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_SET_CMD: /* AT*DSPINFO= */
{
if ( getExtUValue(parameter_values_p, 0, &cmdID, 0, 255, 0) == TRUE )
{
if( getExtString( parameter_values_p, 1, dataBuf, TEL_AT_DSPINFO_STR_MAX_LEN, &dataStrLen , (CHAR *)TEL_AT_DSPINFO_STR_DEFAULT) == TRUE )
{
ERRMSG(ciDspInfo0, "%s: dataBuf %s, dataStrLen %d", __FUNCTION__, dataBuf, dataStrLen);
if ( getExtUValue(parameter_values_p, 2, &NwMode, 0, 255, 255) == TRUE )
{
ret = Dev_SetDspInfo(atHandle, cmdID, dataBuf, NwMode);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
{
ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
/************************************************************************************
* F@: ciBAND - GLOBAL API for AT*LTEBAND command
*
*/
RETURNCODE_T ciSetLTEBand( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
// UNUSEDPARAM(command_name_p);
// UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT8 numOfLteBands=0;
// int lteBands[CI_DEV_MAX_LTE_BAND_ORDER_NUM]={0};
int lteBands[32]={0};
UINT8 index=0;
BOOL cmdValid = TRUE;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT*LTEBAND? */
{
ret = DEV_GetLTEBand(atHandle);
break;
}
case TEL_EXT_SET_CMD: /* AT*LTEBAND= */
{
for(index=0;index<num_parameters;index++)
{
if(parameter_values_p[index].is_default!=TRUE)
{
if(getExtValue(parameter_values_p, index, &(lteBands[index]), TEL_AT_LTEBAND_NW_MODE_VAL_MIN, TEL_AT_LTEBAND_NW_MODE_VAL_MAX, TEL_AT_LTEBAND_NW_MODE_VAL_DEFAULT ) != TRUE)
{
cmdValid=FALSE;
break;
}
}
else
{
if(index==0)cmdValid=FALSE;
break;
}
}
if(cmdValid==FALSE)
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
{
numOfLteBands=index;
ret = DEV_SetLTEBand(atHandle, numOfLteBands, lteBands);
}
break;
}
case TEL_EXT_TEST_CMD:
case TEL_EXT_ACTION_CMD: /* AT*LTEBAND */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciRFTemperatureRead - GLOBAL API for AT*RFTEMP command
*
*/
RETURNCODE_T ciRFTemperatureRead( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciRFTemperatureRead, "ciRFTemperatureRead: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_SET_CMD: /* AT*RFTEMP= */
{
int tempType = 0;
if ( getExtValue(parameter_values_p, 0, &tempType, 0, 3, 0) == TRUE )
{
ret = DEV_ReadRFTemperatureReq(atHandle, (UINT8)tempType);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciLteCoex - GLOBAL API for AT*LTECOEX command
*
*/
RETURNCODE_T ciLteCoex( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciLteCoex, "ciLteCoex: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_SET_CMD: /* AT*LTECOEX= */
{
int enable;
if ( getExtValue(parameter_values_p, 0, &enable, 0, 1, 0) == TRUE )
{
ret = DEV_SetLteCoexReportOptionReq(atHandle, (UINT8)enable);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*LTECOEX? */
{
ret = DEV_GetLteCoexInfoReq(atHandle);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciL2RandFill - GLOBAL API for AT*RANDFILL command
*
*/
RETURNCODE_T ciL2RandFill( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciL2RandFill, "ciL2RandFill: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_SET_CMD: /* AT*RANDFILL= */
{
int option = 0;
BOOL cmdValid = FALSE;
if ( getExtValue(parameter_values_p, 0, &option, 0, 1, 0) == TRUE )
{
cmdValid = TRUE;
}
if (cmdValid == TRUE)
{
ret = DEV_SetL2RandFillReq(atHandle, (CiBoolean)option);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*RANDFILL? */
{
ret = DEV_GetL2RandFillReq(atHandle);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
static const char *const telMode[]= {
"NORMAL", //Normal
"APONLY", //only AP runs
"PRODUCT", //Product mode with GUI
"PRODUCT_NO_GUI", // Product mode without GUI
"L1V", //Layer one validation
"DIAG/AT", //Diag or AT command mode on UART
"IMSC", //IMS
};
void utlUpdateTelModeFromProperty()
{
#if defined (BIONIC)
UINT8 i;
char tmpBuf[PROPERTY_VALUE_MAX];
property_get("persist.sys.telephony.testmode", tmpBuf, "");
for(i = 0; i < sizeof(telMode)/sizeof(telMode[0]); i++)
{
if(strcmp(telMode[i], tmpBuf) == 0)
break;
}
if(i == sizeof(telMode)/sizeof(telMode[0]))
property_set("persist.sys.telephony.testmode", gTelMode); //property value is invalid
else
strcpy(gTelMode, tmpBuf);
#endif
}
/************************************************************************************
* F@: ciTelMode - GLOBAL API for AT*TELMODE command
*
*/
RETURNCODE_T ciTelMode( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
char tmpBuf[utlAT_MAX_LINE_LENGTH] = { 0 };
INT16 len;
UINT8 i;
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciTelMode, "ciTelMode: atHandle = %d.\n", atHandle);
/* No CI primitive for this at command: print hard-coded all reply */
switch (op)
{
case TEL_EXT_TEST_CMD: /* AT*TELMODE=? */
{
int n = sprintf((char *)tmpBuf, "*TELMODE: ");
int size = sizeof(telMode)/sizeof(telMode[0]);
len = 1;
for(i = 0; i < size && len > 0; i++)
{
if(i == 0)
len = snprintf(tmpBuf + n, utlAT_MAX_LINE_LENGTH - n, "(\"%d - %s\"", i, telMode[i]);
else
len = snprintf(tmpBuf + n, utlAT_MAX_LINE_LENGTH - n, ",\"%d - %s\"", i, telMode[i]);
n += len;
if(i == size - 1)
len = snprintf(tmpBuf + n, utlAT_MAX_LINE_LENGTH - n, ")");
}
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)tmpBuf);
break;
}
case TEL_EXT_GET_CMD: /* AT*TELMODE? */
{
utlUpdateTelModeFromProperty();
sprintf((char *)tmpBuf, "*TELMODE: \"%s\"", gTelMode);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)tmpBuf);
break;
}
case TEL_EXT_SET_CMD: /* AT*TELMODE= */
{
int mode;
if(getExtValue(parameter_values_p, 0, &mode, TEL_AT_TELMODE_VALUE_MIN, TEL_AT_TELMODE_VALUE_MAX, TEL_AT_TELMODE_VALUE_DEFAULT) == TRUE)
{
memset(gTelMode, 0, sizeof(gTelMode));
//coverity[buffer_size_warning:SUPPRESS]
strncpy(gTelMode, telMode[mode], sizeof(gTelMode));
#if defined (BIONIC)
property_set("persist.sys.telephony.testmode", gTelMode);
#endif
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
case TEL_EXT_ACTION_CMD: /* AT*TELMODE */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
void clearProxyLists(utlAtProxyCommand_P *pPListHead)
{
utlAtProxyCommand_P pHead, tmp;
pHead = *pPListHead;
//DBGMSG(clearProxyLists, "PROXY_DEBUG - clearProxyLists,%d - clear list %x\n ", __LINE__,pHead);
while(pHead != NULL) {
tmp = pHead;
pHead = tmp->next_p;
//DBGMSG(clearProxyLists1, "PROXY_DEBUG - clearProxyLists,%d - free ptr %x \n ", __LINE__,tmp);
utlFree(tmp->commandName);
utlFree(tmp);
}
*pPListHead = NULL;
}
//add entry to klinked list. Command nam MUST be NULL terminated
BOOL addEntryToProxyList(char *commandName, UINT8 operationCode)
{
BOOL mallocResult = TRUE;
char *pAllocMemForCmdName;
utlAtProxyCommand_P pProxyCmd;
int commandSize;
utlAtProxyCommand_P pListHead;
commandSize = strlen(commandName);
pAllocMemForCmdName = (char*)utlMalloc((commandSize +1));
if(pAllocMemForCmdName == NULL)
{
DBGMSG(addEntryToProxyList, "PROXY_DEBUG - addEntryToProxyList,%d - failed on memory allocation for CMD name\n",
__LINE__);
mallocResult = FALSE;
return mallocResult;
}
pProxyCmd = (utlAtProxyCommand_P)utlMalloc(sizeof(utlAtProxyCommand_T));
if(pProxyCmd == NULL) {
DBGMSG(addEntryToProxyList1, "PROXY_DEBUG - addEntryToProxyList,%d - failed on memory allocation for proxy struct\n",
__LINE__);
mallocResult = FALSE;
utlFree(pAllocMemForCmdName);
return mallocResult;
}
pProxyCmd->operation = (unsigned char)operationCode;
pProxyCmd->commandName = pAllocMemForCmdName;
strcpy(pProxyCmd->commandName,commandName );
WARNMSG(addEntryToProxyList2, "PROXY_DEBUG - addEntryToProxyList,%d - entry name %s, entry operation %d\n ",
__LINE__, pProxyCmd->commandName, pProxyCmd->operation);
//add to linked list
pProxyCmd->prev_p = NULL;
pthread_mutex_lock(&gProxyAccessLock);
if(!operationCode) {
//add an indication
pListHead = atProxyInd;
}
else{
//add a request
pListHead = atProxyReq;
}
if(pListHead == NULL) {
pProxyCmd->next_p=NULL;
} else {
pProxyCmd->next_p=pListHead;
pListHead->prev_p=pProxyCmd;
}
pListHead = pProxyCmd;
if(!operationCode) {
atProxyInd = pListHead;
}
else{
atProxyReq = pListHead;
}
pthread_mutex_unlock(&gProxyAccessLock);
//DBGMSG(addEntryToProxyList3, "PROXY_DEBUG - addEntryToProxyList,%d - req head %x, ind head %x\n ",
// __LINE__,atProxyReq,atProxyInd);
return mallocResult;
}
//decode commands list
//formated as "At<command name>:S or G or T (or any combination)|
BOOL decodeProxyComandStr(char * commandStr)
{
int inputIndex = 0;
char *pEndCommand = NULL;
char *pStartCommnd = NULL;
char *pEndOpSupport = NULL;
char *pStartOpSupport = NULL;
char *pCommandStrEnd = NULL;
int commandSize = 0;
int operationSize = 0;
UINT8 operationCode;
int i,j;
BOOL parseResult = TRUE;
char dots[] = ":";
char line[] = "|";
char s[] = "S";
char t[] = "T";
char g[] = "G";
DBGMSG(decodeProxyComandStr, "PROXY_DEBUG - decodeProxyComandStr,%d - string to pars %s\n",
__LINE__,commandStr);
//get the end of the parsed string
pCommandStrEnd = commandStr + strlen(commandStr);
//DBGMSG(decodeProxyComandStr1, "PROXY_DEBUG - decodeProxyComandStr,%d - final char is %s\n",
// __LINE__,pCommandStrEnd );
while(commandStr[inputIndex]!='\0') {
//DBGMSG(decodeProxyComandStr2, "PROXY_DEBUG - decodeProxyComandStr,%d - inputIndex at %d, str to look for cmd at %s\n",
// __LINE__, inputIndex, &commandStr[inputIndex]);
//find first occurance of ':'
pEndCommand = strstr(&commandStr[inputIndex],dots);
if(!pEndCommand) {
DBGMSG(decodeProxyComandStr3, "PROXY_DEBUG - decodeProxyComandStr,%d - no : found for command end\n",
__LINE__);
parseResult = FALSE;
break;
}
//find command size
commandSize = pEndCommand - &commandStr[inputIndex];
//DBGMSG(decodeProxyComandStr4, "PROXY_DEBUG - decodeProxyComandStr,%d - command size %d\n",
// __LINE__, commandSize);
if((commandSize<=0)||(commandSize > (int)utlAT_MAX_COMMAND_LENGTH)) {
parseResult = FALSE;
break;
}
//find command start (ignorre first 2 char - AT prefix)
pStartCommnd = &commandStr[inputIndex] + 2;
//set null terminator at command end
*pEndCommand = '\0';
//DBGMSG(decodeProxyComandStr5, "PROXY_DEBUG - decodeProxyComandStr,%d - parsed command after clear %s\n",
// __LINE__, pStartCommnd);
//find operations:
inputIndex = inputIndex + commandSize+1;
//DBGMSG(decodeProxyComandStr6, "PROXY_DEBUG - decodeProxyComandStr,%d - input index at %d string to parse %s\n",
// __LINE__, inputIndex, &commandStr[inputIndex]);
//check for operation
pEndOpSupport = strstr(&commandStr[inputIndex],line);
if(!pEndOpSupport) {
//reached the end of the str
pEndOpSupport = pCommandStrEnd;
DBGMSG(decodeProxyComandStr7, "PROXY_DEBUG - decodeProxyComandStr,%d - reached str end",
__LINE__);
}
//find operation string length
operationSize = pEndOpSupport - &commandStr[inputIndex];
//DBGMSG(decodeProxyComandStr8, "PROXY_DEBUG - decodeProxyComandStr,%d - operation size %d",
// __LINE__,operationSize);
if((operationSize<=0)||
(operationSize > (int)utlAT_MAX_LINE_LENGTH)||((unsigned int)operationSize > 3)) {
DBGMSG(decodeProxyComandStr9, "PROXY_DEBUG - decodeProxyComandStr,%d - no : found for operation end\n",
__LINE__);
parseResult = FALSE;
break;
}
//set null terminator at the end of operation
pStartOpSupport = &commandStr[inputIndex];
*pEndOpSupport = '\0';
//DBGMSG(decodeProxyComandStr10, "PROXY_DEBUG - decodeProxyComandStr,%d - operation str %s\n ", __LINE__,pStartOpSupport);
//check operation validity
operationCode = 0;
if(strcasestr(pStartOpSupport,t)) {
operationCode = operationCode | (0x1 << TEL_EXT_TEST_CMD);
//DBGMSG(decodeProxyComandStr11, "PROXY_DEBUG - decodeProxyComandStr,%d - found operation T ", __LINE__);
}
if(strcasestr(pStartOpSupport,s)) {
operationCode = operationCode | (0x1 << TEL_EXT_SET_CMD);
//DBGMSG(decodeProxyComandStr12, "PROXY_DEBUG - decodeProxyComandStr,%d - found operation S ", __LINE__);
}
if(strcasestr(pStartOpSupport,g)) {
operationCode = operationCode | (0x1 << TEL_EXT_GET_CMD);
//DBGMSG(decodeProxyComandStr13, "PROXY_DEBUG - decodeProxyComandStr,%d - found operation G ", __LINE__);
}
//DBGMSG(decodeProxyComandStr14, "PROXY_DEBUG - decodeProxyComandStr,%d - operation code %d\n", __LINE__,operationCode);
if((!operationCode)||(!parseResult)) {
DBGMSG(decodeProxyComandStr15, "PROXY_DEBUG -decodeProxyComandStr,%d - operation code %d,parseResult %d\n",
__LINE__,operationCode,parseResult);
break;
}
//forward index
if(pEndOpSupport != pCommandStrEnd)
{
inputIndex = inputIndex + operationSize+1;
}
else{
inputIndex = inputIndex + operationSize;
}
//create a new entry in the table
parseResult = addEntryToProxyList(pStartCommnd, operationCode);
if(!parseResult) {
break;
}
}
WARNMSG(decodeProxyComandStr16, "PROXY_DEBUG - decodeProxyComandStr,%d -parse result %d\n",
__LINE__,parseResult);
return parseResult ;
}
BOOL decodeProxyIndStr(char * indStr)
{
char parseInd[utlAT_MAX_COMMAND_LENGTH];
int inputIndex = 0;
char *pEndInd = NULL;
char *pStartInd = NULL;
char *pIndStrEnd = NULL;
int indSize = 0;
BOOL parseResult = TRUE;
char dots[] = ":";
//find the end of the parsed string
pIndStrEnd = indStr+ strlen(indStr);
while(indStr[inputIndex]!='\0') {
//DBGMSG(decodeProxyIndStr, "PROXY_DEBUG - decodeProxyIndStr,%d - string to look ind at %s\n",
// __LINE__, &indStr[inputIndex]);
//find first occurance of ':'
pEndInd = strstr(&indStr[inputIndex],dots);
if(!pEndInd) {
DBGMSG(decodeProxyIndStr1, "PROXY_DEBUG - decodeProxyIndStr,%d - reached end of str\n",
__LINE__);
pEndInd = pIndStrEnd;
}
//find command size
indSize = pEndInd - &indStr[inputIndex];
//DBGMSG(decodeProxyIndStr2, "PROXY_DEBUG - decodeProxyIndStr,%d - indication size %d\n",
// __LINE__, indSize);
if((indSize<=0)||(indSize > (int)utlAT_MAX_COMMAND_LENGTH)) {
parseResult = FALSE;
break;
}
pStartInd = &indStr[inputIndex];
*pEndInd = '\0';
//DBGMSG(decodeProxyIndStr3, "PROXY_DEBUG - decodeProxyIndStr,%d - parsed indication %s\n",
// __LINE__,pStartInd);
//forward index
if(pEndInd != pIndStrEnd)
{
inputIndex = inputIndex+ indSize+1;
}
else{
inputIndex = inputIndex+ indSize;
}
//create a new entry in the table
parseResult = addEntryToProxyList(pStartInd, 0);
if(!parseResult) {
DBGMSG(decodeProxyIndStr4, "PROXY_DEBUG - decodeProxyIndStr,%d - break - parse result %d\n",
__LINE__, parseResult);
break;
}
}
WARNMSG(decodeProxyIndStr5, "PROXY_DEBUG - decodeProxyIndStr,%d -parse result %d\n",
__LINE__, parseResult);
return parseResult ;
}
void generateProxyStatusChangeInd(unsigned int proxyStatusReg)
{
char buf[PROPERTY_VALUE_MAX] = {'\0'};
int sim2Flag = 0;
unsigned int indHandle;
char proxyStatusInd[100];
//get the active SIM
#if defined (BIONIC)
property_get("persist.sys.sim2.master.enable", buf, "0");
#endif
sim2Flag = atoi(buf);
if(sim2Flag)
{
//SIM2 active, use IND_HANDLE_1
indHandle = IND_REQ_HANDLE_1;
}
else{
//SIM1 active, use IND_HANDLE
indHandle = IND_REQ_HANDLE;
}
if(proxyStatusReg)
{
sprintf(proxyStatusInd,"*PRXYREGSTATE: %d,%d",proxyStatusReg, gProxyChannelId);
}
else{
sprintf(proxyStatusInd,"*PRXYREGSTATE: 0");
}
ATRESP(indHandle , ATCI_RESULT_CODE_NULL, 0, proxyStatusInd);
}
static int deregProxy(TelAtParserID origParserId)
{
/*
* return value:
* 0: success
* 1: no change(already in de-register status)
* -1: fail, try de-reg proxy that set in another channel
*/
if(gProxyChannelId < NUM_OF_TEL_ATP) //a proxy client is registered, clear proxy status and proxy commands/indications lists
{
//check that de-registration is from the current regsitered channel
if(origParserId == gProxyChannelId) {
aParser_p[gAtpCtrl[gProxyChannelId].index]->isProxy = FALSE;
//clear prxy list
pthread_mutex_lock(&gProxyAccessLock);
clearProxyLists(&atProxyReq);
clearProxyLists(&atProxyInd);
pthread_mutex_unlock(&gProxyAccessLock);
gProxyChannelId = NUM_OF_TEL_ATP;
WARNMSG(ciProxySet2, "PROXY_DEBUG - ciProxySet,%d - after clear req head %x, ind head %d\n", __LINE__,atProxyReq,atProxyInd);
return 0;
}
else{
WARNMSG(ciProxySet3, "PROXY_DEBUG - ciProxySet,%d - deregistration from an AT channel different then original channel\n", __LINE__);
return -1;
}
}
else{
//return OK at any case, even if cleint not registered
//ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
return 1;
}
}
static int RegProxyList( TelAtParserID origParserId,CHAR *commandsList,
const utlAtParameterValue_P2c parameter_values_p,CHAR *indList)
{
int proxyRegSupport = 1;
INT16 commandListLen = 0;
INT16 indListLen = 0;
BOOL indParsingRes = TRUE;
BOOL commandParsingRes = TRUE;
int ret = 0;
int retP = 0;
UINT32 atHandle = MAKE_AT_HANDLE(origParserId);
//check if IMS is enabled
#if defined (BIONIC)
proxyRegSupport = 0;
retP = property_get("persist.sys.telephony.testmode", value, "");
if (retP > 0 && (strcmp(value, "IMSC") == 0)) {
retP = property_get("persist.radio.ims.config", value, "");
if (retP > 0 && ((atoi(value) & 0x2))) {
//IMS-C is enabled
proxyRegSupport = 1;
}
}
#endif
//get indication and commands list
if((proxyRegSupport) && (getExtString(parameter_values_p, 1, commandsList, utlAT_MAX_LINE_LENGTH, &commandListLen, NULL) == TRUE)){
if(getExtString(parameter_values_p, 2, indList, utlAT_MAX_LINE_LENGTH, &indListLen, NULL) == TRUE) {
BOOL parseResult;
//at list one string must have value
if((!indListLen)&&(!commandListLen)) {
if(gNullPrxysetFlag)
{
//ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
DBGMSG(ciProxySet5, "PROXY_DEBUG - ciProxySet,%d - indication list and command lists are emplty\n ", __LINE__);
return -1;
}
else
{
//set gProxyChannelId when IMS send prxyset with NULL commandsList and indList in the beginning
aParser_p[gAtpCtrl[origParserId].index]->isProxy = TRUE;
gProxyChannelId = origParserId;
gNullPrxysetFlag = 1;
}
}
else{
if((gNullPrxysetFlag == 1) || (gProxyChannelId == NUM_OF_TEL_ATP)) {
//no proxy channel is initialized
if(commandListLen) {
// parse commands
commandsList[commandListLen] = '\0';
commandParsingRes = decodeProxyComandStr((char*)commandsList);
}
if((indListLen)&&(commandParsingRes)) {
//parse indications
indParsingRes = decodeProxyIndStr((char*)indList);
}
if(indParsingRes && commandParsingRes) {
//successful parsing
DBGMSG(ciProxySet6, "PROXY_DEBUG - ciProxySet,%d - parsed OK, set isProxy to true\n ", __LINE__);
aParser_p[gAtpCtrl[origParserId].index]->isProxy = TRUE;
gProxyChannelId = origParserId;
//ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
//generate proxy status indication changed
generateProxyStatusChangeInd(1);
ret = 0;
}
else{
//registration failed - clear lists
pthread_mutex_lock(&gProxyAccessLock);
clearProxyLists(&atProxyReq);
clearProxyLists(&atProxyInd);
pthread_mutex_unlock(&gProxyAccessLock);
//ret = ATRESP( atHandle, ATCI_RESULT_CODE_ERROR, 0, NULL);
ret = -1;
}
if(gNullPrxysetFlag == 1)
gNullPrxysetFlag = 0;
return ret;
}
else{
//proxy channel allready opened
DBGMSG(ciProxySet7, "PROXY_DEBUG - ciProxySet,%d - proxy channel allready opened\n ", __LINE__);
return -1;
//ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
}
else{
//INFOMSG(ciProxySet8, "PROXY_DEBUG - ciProxySet,%d - failed on read ind list param\n ", __LINE__);
return -1;
//ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
else{
//INFOMSG(ciProxySet9, "PROXY_DEBUG - ciProxySet,%d - failed on read req list param\n ", __LINE__);
return -1;
//ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
//registration request
return ret;
}
RETURNCODE_T ciProxySet( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
TelAtParserID origParserId = *(TelAtParserID *)arg_p;
//CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(origParserId);
INT32 registerStatus = 0;
utlAtParser_P parser_p;
CHAR commandsList[utlAT_MAX_LINE_LENGTH+1];
CHAR indList[utlAT_MAX_LINE_LENGTH+1];
INT16 indListLen = 0;
INT16 commandListLen = 0;
BOOL indParsingRes = TRUE;
BOOL commandParsingRes = TRUE;
BOOL proxyChannelOpen;
CHAR buf[utlAT_MAX_LINE_LENGTH];
char value[PROPERTY_VALUE_MAX] = "\0";
*xid_p = atHandle;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
//DBGMSG(ciProxySet, "PROXY_DEBUG - ciProxySet: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*PRXYSET=*/
{
//DBGMSG(ciProxySet1, "PROXY_DEBUG - ciProxySet,%d - receive PROXY SET\n ", __LINE__);
if(getExtValue( parameter_values_p, 0, &registerStatus, TEL_AT_PRXYSET_REG_MIN, TEL_AT_PRXYSET_REG_MAX, TEL_AT_PRXYSET_REG_DEFAULT) == TRUE)
{
if(registerStatus==0) {
//de - registration request
int dereg_result = deregProxy(origParserId);
if(dereg_result == 0){
//generate proxy status indication changed
generateProxyStatusChangeInd(registerStatus);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}else if(dereg_result == 1){
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}else{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
else{
//registration request
//1. dereg any way
//2. register
if(deregProxy( origParserId) < 0){
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}else{
//DBGMSG(ciProxySet4, "PROXY_DEBUG - ciProxySet,%d - receive REG requeste\n ", __LINE__);
if(RegProxyList(origParserId,commandsList,parameter_values_p,indList)==0){
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}else{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
}
}
else{
//DBGMSG(ciProxySet10, "PROXY_DEBUG - ciProxySet,%d - failed on read registration param\n ", __LINE__);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*PRXYSET? */
{
if(gProxyChannelId < NUM_OF_TEL_ATP) {
sprintf(( char*)buf, "*PRXYSET: %d,%d\r\n", aParser_p[gAtpCtrl[gProxyChannelId].index]->isProxy, gProxyChannelId);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0,(char*) buf);
}
else{
sprintf(( char*)buf, "*PRXYSET: 0\r\n");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0,(char*) buf);
}
break;
}
case TEL_EXT_TEST_CMD: /* AT*PRXYSET=? */
case TEL_EXT_ACTION_CMD: /* AT*PRXYSET? */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#ifndef NO_AUDIO
#ifdef ECALL_SUPPORT
extern long gMsgID;
extern BOOL gMsgIDUpdateFlag;
#endif
#endif
void checkPrxyCmd(UINT32 handle, char* str)
{
BOOL *pImsRegState = NULL;
if (!GET_SIM1_FLAG(handle)) {
pImsRegState = &gImsRegState;
}
else{
pImsRegState = &gImsRegState_1;
}
DBGMSG(checkPrxyCmd1, "%s:input %s", __func__, str);
if(strlen(str) <= utlAT_MAX_LINE_LENGTH)
{
if(strstr(str, "+CIREGU:")!= NULL)
{
char* index = NULL;
index = strstr(str, ":");
*pImsRegState = atoi((char*)(index+1));
DBGMSG(checkPrxyCmd2, "%s:pImsRegState %d", __func__, *pImsRegState);
}
#ifndef NO_AUDIO
#ifdef ECALL_SUPPORT
else if (strstr(str, "*ECALLDATA: 0,0") != NULL && gMsgIDUpdateFlag == FALSE) {
gMsgID++;
gMsgIDUpdateFlag = TRUE;
if (gMsgID > 255) {
gMsgID = 1;
}
DBGMSG(checkPrxyCmd0, "%s: recv %s, gMsgID %d\n", __FUNCTION__, gMsgID);
}
#endif
#endif
}
return;
}
//handle response from proxy
RETURNCODE_T ciProxyRsp( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CiReturnCode retProxy = CIRC_FAIL;
TelAtParserID origParserId = *(TelAtParserID *)arg_p;
UINT32 atHandle = MAKE_AT_HANDLE(origParserId);
UINT32 xid = 0;
CHAR proxyMsgParam[utlAT_MAX_LINE_LENGTH + 7]; //+7 for PRXYRSP ending
INT16 proxyMsgParamLen;
INT32 intermediateFlag;
INT32 errorType;
INT32 errorCode;
UINT8 resultCodeForParser = ATCI_RESULT_CODE_OK;
UINT8 codeForProxyCahnnelFree = ATCI_RESULT_CODE_OK;
unsigned int proxyFlag = 0;
unsigned int forwardToProxy = 0;
char prxyRspEnd[] = "PRXYRSP";
BOOL bSMSPrompt = FALSE;
*xid_p = atHandle;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
//DBGMSG(ciProxyRsp, "PROXY_DEBUG - ciProxyRsp: atHandle = %d, from original parser ID %d\n", atHandle,origParserId );
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*PRXYRSP=*/
{
//DBGMSG(ciProxyRsp1, "PROXY_DEBUG - ciProxyRsp,%d - receive PROXY RSP\n ", __LINE__);
if(getExtUValue( parameter_values_p, 0, &xid, TEL_AT_PRXYRSP_XID_MIN, TEL_AT_PRXYRSP_XID_MAX, TEL_AT_PRXYRSP_XID_DEFAULT) == TRUE)
{
//get indication and commands list
if(getExtString(parameter_values_p, 1, proxyMsgParam, utlAT_MAX_LINE_LENGTH, &proxyMsgParamLen, NULL) == TRUE){
if(getExtValue( parameter_values_p, 2, &intermediateFlag, TEL_AT_PRXYRSP_INTER_MIN, TEL_AT_PRXYRSP_INTER_MAX, TEL_AT_PRXYRSP_INTER_DEFAULT) == TRUE){
if(getExtValue( parameter_values_p, 3, &errorType,
TEL_AT_PRXYRSP_ERROR_TYEP_MIN, TEL_AT_PRXYRSP_ERROR_TYEP_MAX, TEL_AT_PRXYRSP_ERROR_TYEP_DEFAULT) == TRUE) {
if(getExtValue( parameter_values_p, 4, &errorCode,
TEL_AT_PRXYRSP_ERROR_CODE_MIN, TEL_AT_PRXYRSP_ERROR_CODE_MAX, TEL_AT_PRXYRSP_ERROR_CODE_DEFAULT) == TRUE) {
DBGMSG(ciProxyRsp2, "PROXY_DEBUG - ciProxyRsp,%d - PRXY RSP with XID %d,str %s,strlen %d\n ", __LINE__,xid,proxyMsgParam, proxyMsgParamLen);
//differ between indications to forward and response
if((xid == IND_REQ_HANDLE)||(xid == IND_REQ_HANDLE_1)) {
//check if a registered proxy indication.
proxyFlag = utlIsProxyInd((char*)proxyMsgParam,xid);
DBGMSG(ciProxyRsp3, "PROXY_DEBUG - ciProxyRsp,%d - proxy flag for str %s is %d \n ", __LINE__,proxyMsgParam , proxyFlag);
if(proxyFlag) {
//VDBGMSG(ciProxyRsp4, "PROXY_DEBUG - ciProxyRsp,%d - forward indications %s to all channels but proxy \n ", __LINE__,proxyMsgParam );
checkPrxyCmd(xid, proxyMsgParam);
//add prox finish to show this string was generated by proxy
strcat((char*)proxyMsgParam,prxyRspEnd);
//VDBGMSG(ciProxyRsp5, "PROXY_DEBUG - ciProxyRsp,%d - indications %s after concat \n ", __LINE__,proxyMsgParam );
//send string to all channels
ret = ATRESP( xid, ATCI_RESULT_CODE_NULL, 0, (char*)proxyMsgParam);
}
//free the proxy channel
if(!ret) {
codeForProxyCahnnelFree = ATCI_RESULT_CODE_OK;
}
else{
codeForProxyCahnnelFree = ATCI_RESULT_CODE_ERROR;
}
//VDBGMSG(ciProxyRsp6, "PROXY_DEBUG - ciProxyRsp,%d - write response to proxy channel with code %d \n ", __LINE__,codeForProxyCahnnelFree );
retProxy = ATRESP( atHandle, codeForProxyCahnnelFree, 0, NULL);
//DBGMSG(ciProxyRsp7, "PROXY_DEBUG - ciProxyRsp,%d - result for free proxy %d \n ", __LINE__,retProxy );
}
else{
//repsons
//send to original parser ID
DBGMSG(ciProxyRsp8, "PROXY_DEBUG - ciProxyRsp,%d - sending message to channel %d, str %s\n ", __LINE__,GET_ATP_INDEX(xid) ,proxyMsgParam);
//check if we need to handle error
if(errorType != ATCI_RESULT_CODE_OK) {
//handle error. Check typeand send relevant error
switch(errorType) {
case ATCI_RESULT_CODE_ERROR:
resultCodeForParser = ATCI_RESULT_CODE_SUPPRESS; //the error message is part of the prxy string, no extra error needed from the parser
break;
case ATCI_RESULT_CODE_CME_ERROR_PROXY:
case ATCI_RESULT_CODE_CMS_ERROR_PROXY:
resultCodeForParser = errorType;
break;
default:
resultCodeForParser = ATCI_RESULT_CODE_SUPPRESS;
break;
}
//DBGMSG(ciProxyRsp9, "PROXY_DEBUG - ciProxyRsp,%d - handle error - result code %d, error code %d, str %s\n ",
// __LINE__,resultCodeForParser, errorCode,proxyMsgParam);
//send error message to the original client
ret = ATRESP( xid, resultCodeForParser, errorCode, (proxyMsgParamLen == 0)? NULL:(char*)proxyMsgParam);
}
else{
//this is a standard response
if(intermediateFlag) {
resultCodeForParser = ATCI_RESULT_CODE_NULL;
}
else{
resultCodeForParser = ATCI_RESULT_CODE_OK;
}
//check if the XID is part of the SMS transaction.
//if yes - set the datamode for the AT channel to true
if(gCurrentProxyTrsXid == xid){
if(gCurrentPrxyFirstPhase == TRUE)
{
//first phase of the transaction expect SMS data
gAtpCtrl[GET_ATP_INDEX(xid)].pTelAtpDataEntry.smsDataEntryMode = gCurrentSmsDataMode;
//DBGMSG(ciProxyRsp10, "PROXY_SMS_DEBUG - ciProxyRsp,%d - channel %d mode %d, set to true, xid %d - \n ", __LINE__,GET_ATP_INDEX(xid),gAtpCtrl[GET_ATP_INDEX(xid)].pTelAtpDataEntry.smsDataEntryMode, xid );
gCurrentPrxyFirstPhase = FALSE;
resetMsgOperFlag(GET_AT_HANDLE(xid));
// PRXYRSP here must contain SMS prompt. Send OK to PRXYRSP before forwarding the
// prompt to app, to ensure that the SMS data from app reach the proxy later than
// this OK.
bSMSPrompt = TRUE;
retProxy = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
//INFOMSG(ciProxyRsp11, "PROXY_SMS_DEBUG -ciProxyRsp,%d - for channel %d mode %d, - \n ", __LINE__,GET_ATP_INDEX(xid),gAtpCtrl[GET_ATP_INDEX(xid)].pTelAtpDataEntry.smsDataEntryMode );
}
if((ims_sms_data_invalid_report_error == TRUE) && (gCurrentProxyTrsXid == xid))
{
ims_sms_data_invalid_report_error = FALSE;
ret = ATRESP( xid, ATCI_RESULT_CODE_CMS_ERROR, CMS_INVALID_TEXT_MODE_PARA, NULL);
}
else
{
ret = ATRESP( xid, resultCodeForParser, 0, (char*)proxyMsgParam);
}
}
//free the proxy channel
if(!ret) {
codeForProxyCahnnelFree = ATCI_RESULT_CODE_OK;
}
else{
codeForProxyCahnnelFree = ATCI_RESULT_CODE_ERROR;
}
if (!bSMSPrompt)
retProxy = ATRESP( atHandle, codeForProxyCahnnelFree, 0, NULL);
}
}
else{
//DBGMSG(ciProxyRsp12, "PROXY_DEBUG - ciProxyRsp,%d - proxy rsp failed on optionnal param\n ", __LINE__ );
retProxy = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
else{
//DBGMSG(ciProxyRsp13, "PROXY_DEBUG - ciProxyRsp,%d - proxy rsp failed on optionnal param\n ", __LINE__ );
retProxy = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
else{
//DBGMSG(ciProxyRsp14, "PROXY_DEBUG - ciProxyRsp,%d - proxy rsp failed on optionnal param\n ", __LINE__ );
retProxy = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
else{
//DBGMSG(ciProxyRsp15, "PROXY_DEBUG - ciProxyRsp,%d - proxy rsp failed on receiving str\n ", __LINE__ );
retProxy = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
else{
//DBGMSG(ciProxyRsp16, "PROXY_DEBUG - ciProxyRsp,%d - proxy rsp failed on receiving xid\n ", __LINE__ );
retProxy = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD:
case TEL_EXT_TEST_CMD: /* AT*PRXYSET=? */
case TEL_EXT_ACTION_CMD: /* AT*PRXYSET? */
default:
{
retProxy = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
//DBGMSG(ciProxyRsp17, "PROXY_DEBUG - ciProxyRsp,%d - ret value %d retProxy value %d \n ", __LINE__,ret ,retProxy);
rc = HANDLE_RETURN_VALUE(retProxy);
return(rc);
}
//create proxy message prefix
void createProxyExtStr(UINT32 xid, char *msgToProxy)
{
char xidBuf[13]; //number of digits for 2^32-1 +"," + Null
//conver command XID to str
memset(xidBuf,0 ,sizeof(xidBuf));
sprintf(xidBuf,"%d,",xid);
//copy PROXY init
sprintf(msgToProxy,"*PRXY: ");
//add xid
strcat(msgToProxy,xidBuf);
//DBGMSG(createProxyExtStr, "PROXY_DEBUG - createProxyExtStr,%d - create prefix %s\n ", __LINE__,msgToProxy);
}
//For all strings, except strings starting with +CMT - go over parameter string, and replace special characters
//- " is replaced with \022 str
//for +CMT indication - add " in the middle to comply for IMS requests (and don't check
//for specific chars - MT SMS is supported only in PDU mode for proxy)
//Note - the input string lengthshould include the null termination, to allow handling strings that are not null terminated.
unsigned int replaceSpacielCharForProxy(const char *srcParam, unsigned int srsParamLen,char *resParam, unsigned int resParamLength)
{
char quotStrReplace[] = "\\22" ;
char cmtStr[] = "+CMT";
char quotStr[] = "\" ";
char lncrStr[] = "\r\n";
unsigned int size;
char *pQuatLocation = NULL;
unsigned int numUsedCharsForRes = 0;
unsigned int srcCharIndex = 0;
unsigned int result = CIRC_SUCCESS;
//check first if str is null terminated - if not, it cannot be +CMT indication, and we can't check for +CMT str
if(srcParam[srsParamLen-1] == '\0')
{
//DBGMSG(replaceSpacielCharForProxy, "PROXY_DEBUG - replaceSpacielCharForProxy,%d - Not SMS MO data \n ", __LINE__ );
if(strcasestr(srcParam, cmtStr))
{
pQuatLocation = (char *)strcasestr(srcParam,lncrStr);
}
}
else{
//DBGMSG(replaceSpacielCharForProxy1, "PROXY_DEBUG - replaceSpacielCharForProxy,%d - handle SMS MO data \n ", __LINE__ );
}
while((*srcParam !='\0')&&(numUsedCharsForRes < resParamLength) && (srcCharIndex < srsParamLen))
{
if((!pQuatLocation)&&(*srcParam == '\"'))
{
size = strlen(quotStrReplace);
strncpy(resParam,quotStrReplace,size);
resParam = resParam+size;
numUsedCharsForRes = numUsedCharsForRes + size;
}
else if(pQuatLocation){ //for +CMT indications - find \r\n and add " before
if(srcParam == pQuatLocation) //" should be located before \r\n
{
//add "
*resParam= '\"';
resParam++;
numUsedCharsForRes++;
}
//continue to copy
*resParam = *srcParam;
resParam++;
numUsedCharsForRes++;
}
else{
//just copy
*resParam = *srcParam;
resParam++;
numUsedCharsForRes++;
}
//go to next char
srcParam++;
srcCharIndex++;
}
if((*srcParam != '\0')&&(numUsedCharsForRes == resParamLength))
{
ERRMSG(replaceSpacielCharForProxy2, "ERROR: failed replacing special string for proxy - dest array too short ");
resParam[numUsedCharsForRes-1] = '\0';
result = CIRC_FAIL;
}
else{
*resParam = '\0';
}
return result;
}
//the function receives the command name string and command parameters string and operation, and concatenate them into a single string. Then - sends the
//string to proxy.
//*arg_p is the parser ID the command was received on, and is sent as a parameter
utlReturnCode_T createStringToProxy(const char *command_name_p,const utlAtParameterOp_T op, const char *parameters_string_p,unsigned int *xid_p,void *arg_p)
{
char *msgToProxy = NULL; //PROXY: <commandname>,<command param>
char setOp[] = "=";
char getOp[] = "?";
char testOp[] = "=?";
char exeOp[] = "";
char quotes[] = "\"";
char atStr[] ="\"AT";
char xidBuf[13]; //number of digits for 2^32-1 +"," + Null
char *paramToPrxy = NULL;
TelAtParserID origParserId = *(TelAtParserID *)arg_p;
UINT32 xid = MAKE_AT_HANDLE(origParserId);
UINT32 atHandleForProxyChannel = MAKE_AT_HANDLE(gProxyChannelId);
CiReturnCode ret = CIRC_FAIL;
CiReturnCode convertRes = CIRC_SUCCESS;
RETURNCODE_T rc = INITIAL_RETURN_CODE;
BOOL stringValid = TRUE;
char *parameters_string_p_new = NULL;
if(xid_p !=NULL) { //async command
*xid_p = xid;
}
msgToProxy = utlCalloc(1, utlAT_PRXY_EXT_LENGTH + utlAT_MAX_COMMAND_LENGTH + utlAT_MAX_LINE_LENGTH);
if (msgToProxy == NULL)
return rc;
paramToPrxy = utlCalloc(1, utlAT_MAX_LINE_LENGTH*2);
if (paramToPrxy == NULL)
{
utlFree(msgToProxy);
return rc;
}
//DBGMSG(createStringToProxy, "PROXY_DEBUG - createStringToProxy,%d - forward msg to proxy - cmd name %s, cmd param %s, op %d, in behalf of parser %d\n ", __LINE__,
// command_name_p, parameters_string_p,(int)op,origParserId );
if(!strncasecmp(command_name_p, "+CMGF", strlen("+CMGF"))) {
gOrigParserId = origParserId;
}
memset(msgToProxy, 0, sizeof(msgToProxy));
//create prxy indication extention
createProxyExtStr(xid,msgToProxy);
//DBGMSG(createStringToProxy1, "PROXY_DEBUG - createStringToProxy,%d - forward msg to prox - ext is %s\n ", __LINE__,msgToProxy);
//add AT prefix and first "
strcat(msgToProxy,atStr);
//add command name
//coverity[parameter_as_source:SUPPRESS]
strcat(msgToProxy,command_name_p);
//write op code
switch(op) {
case TEL_EXT_SET_CMD:
strcat(msgToProxy,setOp );
break;
case TEL_EXT_GET_CMD:
strcat(msgToProxy,getOp);
break;
case TEL_EXT_TEST_CMD:
strcat(msgToProxy,testOp);
break;
case TEL_EXT_EXEC_CMD:
case TEL_EXT_ACTION_CMD:
strcat(msgToProxy,exeOp);
break;
default:
ret = ATRESP( xid, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL); //send back to sending channel
stringValid = FALSE;
}
if(stringValid) {
//concatenate parameters
if(parameters_string_p!=NULL ) {
//check for spaciel chars in string
if(!strcasecmp("+CMSS", (char*)command_name_p) && strstr(parameters_string_p,","))
{
parameters_string_p_new = utlCalloc(1, strlen(parameters_string_p)+1);
if(parameters_string_p_new == NULL)
convertRes = replaceSpacielCharForProxy(parameters_string_p,strlen(parameters_string_p)+1,paramToPrxy,utlAT_MAX_LINE_LENGTH*2);
memset(parameters_string_p_new, 0, strlen(parameters_string_p)+1);
ret = processProxyCMSSDestAddr((char *)parameters_string_p, parameters_string_p_new, origParserId);
if(ret)
convertRes = replaceSpacielCharForProxy(parameters_string_p,strlen(parameters_string_p)+1,paramToPrxy,utlAT_MAX_LINE_LENGTH*2);
else
convertRes = replaceSpacielCharForProxy(parameters_string_p_new,strlen(parameters_string_p_new)+1,paramToPrxy,utlAT_MAX_LINE_LENGTH*2);
}
else
convertRes = replaceSpacielCharForProxy(parameters_string_p,strlen(parameters_string_p)+1,paramToPrxy,utlAT_MAX_LINE_LENGTH*2);
}
if(convertRes == CIRC_SUCCESS ){
//parameter conversion either success, or didn't happen..
if(parameters_string_p)
{
strncat(msgToProxy,paramToPrxy, sizeof(msgToProxy)-strlen(msgToProxy)-strlen(quotes));
}
//add finel quotes
strcat(msgToProxy,quotes);
//INFOMSG(createStringToProxy2, "PROXY_DEBUG - createStringToProxy,%d - str to proxy %s, xid to RSP %d - \n ", __LINE__,msgToProxy, atHandleForProxyChannel );
//save the XID sent to the proxy, incase for an ongoing transaction
if(utlIsProxySmsTrs(command_name_p)){
DBGMSG(createStringToProxy3, "PROXY_SMS_DEBUG -createStringToProxy,%d - xid %d is for SMS transaction - \n ",__LINE__, xid );
gCurrentProxyTrsXid = xid;
gCurrentPrxyFirstPhase = TRUE;
}
//send to proxy - send it as an indication, noneed to free the parser pf the proxy channel since it wasn't locked at the first place...
ret = ATRESP( atHandleForProxyChannel, ATCI_RESULT_CODE_NULL, 0, msgToProxy);
}
else{
//conversion for proxy chars failed - return error
ret = ATRESP( xid, ATCI_RESULT_CODE_CME_ERROR, CME_TEXT_STRING_TOO_LONG, NULL); //send back to sending channel
}
}
rc = HANDLE_RETURN_VALUE(ret);
if(msgToProxy != NULL)
utlFree(msgToProxy);
if(parameters_string_p_new != NULL)
utlFree(parameters_string_p_new);
if(paramToPrxy != NULL)
utlFree(paramToPrxy);
return rc;
}
/************************************************************************************
/ * F@: ciIMLCONFIG - GLOBAL API for AT*IMLCONFIG-command
*
*/
RETURNCODE_T ciIMLCONFIG( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciIMLCONFIG, "ciIMLCONFIG: atHandle = %d.\n", atHandle);
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*IMLCONFIG=*/
{
int IMLType = 0;
INT16 len = 0;
CHAR data[CI_DEV_MAX_IML_CFG_LEN * 2 + ATCI_NULL_TERMINATOR_LENGTH];
BOOL cmdValid = FALSE;
if(getExtValue( parameter_values_p, 0, &IMLType, TEL_AT_IMLCONFIG_TYPE_VAL_MIN, TEL_AT_IMLCONFIG_TYPE_VAL_MAX, TEL_AT_IMLCONFIG_TYPE_VAL_DEFAULT) == TRUE)
{
if(getExtString(parameter_values_p, 1, data, CI_DEV_MAX_IML_CFG_LEN * 2, &len, NULL) == TRUE)
{
cmdValid = TRUE;
ret = DEV_SetIMLConfigReq(atHandle, (UINT8)IMLType, (int)len, (char *)data);
}
}
if(!cmdValid)
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
case TEL_EXT_GET_CMD: /* AT*IMLCONFIG? */
{
ret = DEV_GetIMLConfigReq(atHandle);
break;
}
case TEL_EXT_TEST_CMD: /* AT*IMLCONFIG=? */
case TEL_EXT_ACTION_CMD: /* AT*IMLCONFIG */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciSetSerialPortIndicationState - GLOBAL API for AT*SPIND-command
*
*/
RETURNCODE_T ciSetSerialPortIndicationState(const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
TelAtParserID atpId = *(TelAtParserID *)arg_p;
TelAtpDesc *pTelAtpDesc = getTelAtpDesc(atpId);
*xid_p = atHandle;
//DBGMSG(ciSetSerialPortIndicationState, "ciSetSerialPortIndicationState: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*SPIND= */
{
int type;
if(getExtValue( parameter_values_p, 0, &type, 0, 1, 0) == TRUE)
{
pTelAtpDesc->needIndication = type == 0 ? FALSE : TRUE;
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*SPIND?*/
{
char buf[100] = {0};
int type;
type = pTelAtpDesc->needIndication == TRUE ? 1 : 0;
sprintf(buf, "*SPIND: %d\r\n", type);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, buf);
break;
}
case TEL_EXT_ACTION_CMD: /* AT*SPIND */
case TEL_EXT_TEST_CMD: /* AT*SPIND=? */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#ifdef OPERATOR_ATT
/*************************************************************************
* F@: ciIGNSwitch - GLOBAL API for AT*IGN
*
************************************************************************/
RETURNCODE_T ciIGNSwitch(const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
BOOL cmdValid = FALSE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciIGNSwitch, "ciIGNSwitch: atHandle = %d.\n", atHandle);
/*
** Check the operation type.
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT*IGN? */
{
ret = DEV_IGNGet(atHandle);
break;
}
case TEL_EXT_SET_CMD: /* AT*IGN= */
{
INT32 ignitionOn;
INT32 slowFratTimer = TEL_AT_IGN_TIMER_SLOW_MIN;
INT32 fastFratTimer = TEL_AT_IGN_TIMER_FAST_MIN;
BOOL updateFastFratTimer = FALSE;
BOOL updateSlowFratTimer = FALSE;
if ((getExtValue(parameter_values_p, 0, &ignitionOn, TEL_AT_IGN_MIN, TEL_AT_IGN_MAX, TEL_AT_IGN_DEFAULT)==TRUE) &&
(getExtValue(parameter_values_p, 1, &slowFratTimer, TEL_AT_IGN_TIMER_SLOW_MIN, TEL_AT_IGN_TIMER_SLOW_MAX, TEL_AT_IGN_TIMER_ERROR_PARAM)==TRUE) &&
(getExtValue(parameter_values_p, 2, &fastFratTimer, TEL_AT_IGN_TIMER_FAST_MIN, TEL_AT_IGN_TIMER_FAST_MAX, TEL_AT_IGN_TIMER_ERROR_PARAM)==TRUE))
{
if ((fastFratTimer == TEL_AT_IGN_TIMER_ERROR_PARAM) && (slowFratTimer == TEL_AT_IGN_TIMER_ERROR_PARAM))
{
cmdValid = TRUE;
}
else if ((fastFratTimer != TEL_AT_IGN_TIMER_ERROR_PARAM) && (slowFratTimer != TEL_AT_IGN_TIMER_ERROR_PARAM))
{
updateFastFratTimer = TRUE;
updateSlowFratTimer = TRUE;
cmdValid = TRUE;
}
}
if (cmdValid)
{
ret = DEV_IGNSet(atHandle, ignitionOn, slowFratTimer, fastFratTimer, updateSlowFratTimer, updateFastFratTimer);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciPlusRSRP - GLOBAL API for AT+RSRP command.
* Used in AT&T IDLE Mode Test cases
*
************************************************************************************/
RETURNCODE_T ciPlusRSRP(const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
UNUSEDPARAM(parameter_values_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciPlusRSRP, "ciPlusRSRP: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+RSRP? */
{
ret = DEV_GetATTLteMeasReq(atHandle, RSRP_FLAG);//flag(0-RSRP,1-RSRQ)
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciPlusRSRQ - GLOBAL API for AT+RSRQ command.
* Used in AT&T IDLE Mode Test cases
*
************************************************************************************/
RETURNCODE_T ciPlusRSRQ(const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
UNUSEDPARAM(parameter_values_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciPlusRSRQ, "ciPlusRSRQ: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+RSRP? */
{
ret = DEV_GetATTLteMeasReq(atHandle, RSRQ_FLAG);//flag(0-RSRP,1-RSRQ)
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciRSCP - GLOBAL API for AT+RSCP command.
* Used in AT&T IDLE Mode Test cases
*
************************************************************************************/
RETURNCODE_T ciPlusRSCP(const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
UNUSEDPARAM(parameter_values_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciPlusRSCP, "ciPlusRSCP: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+RSRP? */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciECNO - GLOBAL API for AT+ECNO command.
* Used in AT&T IDLE Mode Test cases
*
************************************************************************************/
RETURNCODE_T ciPlusECNO(const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
UNUSEDPARAM(parameter_values_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciPlusECNO, "ciPlusECNO: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+RSRP? */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
/************************************************************************************
/ * F@: ciCELLINFO - GLOBAL API for AT*CELLINFO-command
*
*/
RETURNCODE_T ciCELLINFO(const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters, const char *info_text_p, unsigned int *xid_p, void *arg_p)
{
BOOL cmdValid = FALSE;
INT32 modeVal;
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciCELLINFO, "ciCELLINFO: atHandle = %d.\n", atHandle);
switch ((int)op) {
case TEL_EXT_TEST_CMD: /* AT*CELLINFO=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0,
(char *)"*CELLINFO:<mode> [0:disable the periodic reporting; 1: enable the reporting]");
break;
}
case TEL_EXT_GET_CMD: /* AT*CELLINFO? */
{
/* Currently GET is NOT supported */
if (g_IsCgedOn) {
ret = ATRESP( atHandle, ATCI_RESULT_CODE_ERROR, CME_OPERATION_NOT_SUPPORTED,
(char *)"*CELLINFO: ERROR - +CGED is working");
} else {
ret = ATRESP( atHandle, ATCI_RESULT_CODE_ERROR, CME_OPERATION_NOT_SUPPORTED,
(char *)"*CELLINFO? is not supported");
}
break;
}
case TEL_EXT_SET_CMD: /* AT*CELLINFO= */
{
/* The AT Command is: at*cellinfo=1 or at*cellinfo=0 */
if (g_IsCgedOn) {
ret = ATRESP( atHandle, ATCI_RESULT_CODE_ERROR, CME_OPERATION_NOT_SUPPORTED,
(char *)"*CELLINFO: ERROR - +CGED is working");
} else if (getExtValue(parameter_values_p, 0, &modeVal, TEL_AT_CELLINFO_MODE_VAL_MIN,
TEL_AT_CELLINFO_MODE_VAL_MAX, TEL_AT_CELLINFO_MODE_VAL_DEFAULT) == TRUE) {
ret = DEV_SetCellInfoReq(atHandle, modeVal);
} else {
ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
}
break;
}
case TEL_EXT_ACTION_CMD: /* AT*CELLINFO */
default:
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/* AT+OPERCFG command*/
/************************************************************************************
* F@: ciSetOperCfg - GLOBAL API for AT+OPERCFG command
*
*/
RETURNCODE_T ciSetOperCfg( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
CiDevPrimSetOperConfigReq *setOperCfgReq = NULL;
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciSetOperCfg, "ciSetOperCfg: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+OPERCFG? */
{
ret = DEV_GetOperCfg_req(atHandle, 0, 0);
break;
}
case TEL_EXT_SET_CMD: /* AT+OPERCFG= */
{
UINT8 mode;
int feature_id=0;
//int feature_value=0;
UINT8 index=0;
BOOL cmdValid = FALSE;
UINT8 numFeatures=0;
char feature_value[16] = {0};
INT16 StrLen = 0;
setOperCfgReq = (CiDevPrimSetOperConfigReq *)utlCalloc(1, sizeof(CiDevPrimSetOperConfigReq));
if(NULL == setOperCfgReq)
{
//ERRMSG(ciSetOperCfg1, "ciSetOperCfg: alloc fail\n");
break;
}
for(index = 0; index < num_parameters; index++)
{
if(parameter_values_p[index].is_default != TRUE)
{
if(index % 2 == 0)
{
if(getExtValue(parameter_values_p, index, &feature_id, TEL_AT_OPERCFG_FEATUREID_VAL_MIN, TEL_AT_OPERCFG_FEATUREID_VAL_MAX, TEL_AT_OPERCFG_FEATUREID_VAL_DEFAULT) == TRUE)
{
setOperCfgReq->feature[numFeatures].featureId = (UINT32)feature_id;
}
else
{
cmdValid=FALSE;
break;
}
}
else
{
if(getExtString(parameter_values_p, index, feature_value, 16, &StrLen, NULL) == TRUE)
{
setOperCfgReq->feature[numFeatures].featureValue = strtoul(feature_value,NULL,0);
numFeatures++;
if((UINT32)(index + 1) == num_parameters)
{
mode = 1;
setOperCfgReq->numFeatures = numFeatures;
cmdValid = TRUE;
}
}
else
{
cmdValid=FALSE;
break;
}
}
}
else
{
if(index == 1)
{
mode = 0;
cmdValid = TRUE;
}
else if(index % 2 == 0)
{
mode = 1;
setOperCfgReq->numFeatures = numFeatures;
cmdValid = TRUE;
}
else
{
cmdValid = FALSE;
}
break;
}
}
if(cmdValid==FALSE)
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
{
if(0 == mode)
{
ret = DEV_GetOperCfg_req(atHandle, 1, (UINT32)feature_id);
}
else
{
ret = DEV_SetOperCfg_req(atHandle, setOperCfgReq);
}
}
if(NULL != setOperCfgReq)
utlFree(setOperCfgReq);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciUdconf - GLOBAL API for AT*DCONF command.
*
*/
RETURNCODE_T ciUdconf(const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters, const char *info_text_p, unsigned int *xid_p, void *arg_p)
{
BOOL cmdValid = FALSE;
INT32 commandId;
INT32 soar_enable;
INT32 speechCodec;
INT32 gprsProf;
INT32 edgeProf;
INT32 simHotIns;
INT32 simPrfProt;
INT32 fpdchEn;
INT32 ffdormancy;
INT32 ddtConfig;
INT32 posCap;
INT32 ciphoAlg;
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
BOOL Check3Param = TRUE;
INT32 extraDefaultParam;
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
UNUSEDPARAM(arg_p);
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
#if 0
switch ((int)op) {
case TEL_EXT_SET_CMD: /* AT+UDCONF= */
{
if (getExtValue
(parameter_values_p, 0, &commandId, TEL_AT_UDCONF_VAL_MIN, TEL_AT_UDCONF_VAL_MAX,
TEL_AT_UDCONF_VAL_DEFAULT) == TRUE) {
//first parameter is command
switch (commandId) {
case 20:
{
if (getExtValue
(parameter_values_p, 1, &soar_enable, TEL_AT_UDCONF_ROAMENABLE_VAL_MIN,
TEL_AT_UDCONF_ROAMENABLE_VAL_MAX,TEL_AT_UDCONF_ROAMENABLE_VAL_DEFAULT) == TRUE) {
if(soar_enable != TEL_AT_UDCONF_ROAMENABLE_VAL_DEFAULT) {
//SET command
ret = ciUdconf20Set(soar_enable,atHandle);
cmdValid = TRUE;
}
else{
//GET
ret = ciUdconf20Get(atHandle);
cmdValid = TRUE;
}
}
break;
}
case 30:
if (getExtValue
(parameter_values_p, 1, &speechCodec, TEL_AT_UDCONF_SPEECHCO_VAL_MIN, TEL_AT_UDCONF_SPEECHCO_VAL_MAX,
TEL_AT_UDCONF_SPEECHCO_VAL_DEFAULT) == TRUE) {
if(speechCodec != TEL_AT_UDCONF_SPEECHCO_VAL_DEFAULT) {
//SET command
ret = ciUdconf30Set(speechCodec,atHandle);
cmdValid = TRUE;
}
else{
//GET
ret = ciUdconf30Get(atHandle);
cmdValid = TRUE;
}
break;
}
case 40:
if (getExtValue
(parameter_values_p, 1, &gprsProf, TEL_AT_UDCONF_GPRS_VAL_MIN, TEL_AT_UDCONF_GPRS_VAL_MAX,
TEL_AT_UDCONF_GPRS_VAL_DEFAULT) == TRUE) {
if(getExtValue
(parameter_values_p, 2, &edgeProf, TEL_AT_UDCONF_EDGE_VAL_MIN, TEL_AT_UDCONF_EDGE_VAL_MAX,
TEL_AT_UDCONF_EDGE_VAL_DEFAULT) == TRUE) {
if((gprsProf == TEL_AT_UDCONF_GPRS_VAL_DEFAULT)&&(edgeProf == TEL_AT_UDCONF_EDGE_VAL_DEFAULT)){
//GET
ret = ciUdconf40Get(atHandle);
cmdValid = TRUE;
Check3Param = FALSE;
}
else if(gprsProf != TEL_AT_UDCONF_GPRS_VAL_DEFAULT){//for set oper - first param is require
//SET command
ret = ciUdconf40Set(gprsProf, edgeProf,atHandle);
cmdValid = TRUE;
Check3Param = FALSE;
}
}
}
if(!cmdValid) {
ret = CIRC_FAIL;
}
break;
case 50:
if (getExtValue
(parameter_values_p, 1, &simHotIns, TEL_AT_UDCONF_SIMINS_VAL_MIN, TEL_AT_UDCONF_SIMINS_VAL_MAX,
TEL_AT_UDCONF_SIMINS_VAL_DEFAULT) == TRUE) {
if(simHotIns!=TEL_AT_UDCONF_SIMINS_VAL_DEFAULT) {
//SET command
ret = ciUdconf50Set(simHotIns,atHandle);
cmdValid = TRUE;
}
else{
//GET
ret = ciUdconf50Get(atHandle);
cmdValid = TRUE;
}
}
break;
case 51:
if (getExtValue
(parameter_values_p, 1, &simPrfProt, TEL_AT_UDCONF_SIMPRO_VAL_MIN, TEL_AT_UDCONF_SIMPRO_VAL_MAX,
TEL_AT_UDCONF_SIMPRO_VAL_DEFAULT) == TRUE) {
if(simPrfProt!= TEL_AT_UDCONF_SIMPRO_VAL_DEFAULT) {
//SET command
ret = ciUdconf51Set(simPrfProt,atHandle);
cmdValid = TRUE;
}
else
{
ret = ciUdconf51Get(atHandle);
cmdValid = TRUE;
}
}
break;
case 60:
if (getExtValue
(parameter_values_p, 1, &fpdchEn, TEL_AT_UDCONF_FPDCHEN_VAL_MIN, TEL_AT_UDCONF_FPDCHEN_VAL_MAX,
TEL_AT_UDCONF_SIMPRO_VAL_DEFAULT) == TRUE) {
if(fpdchEn != TEL_AT_UDCONF_SIMPRO_VAL_DEFAULT) {
//SET command
ret = ciUdconf60Set(fpdchEn,atHandle);
cmdValid = TRUE;
}
else
{
//GET
ret = ciUdconf60Get(atHandle);
cmdValid = TRUE;
}
}
break;
case 61:
if (getExtValue
(parameter_values_p, 1, &ffdormancy, TEL_AT_UDCONF_FFDRMNCY_VAL_MIN, TEL_AT_UDCONF_FFDRMNCY_VAL_MAX,
TEL_AT_UDCONF_FFDRMNCY_VAL_DEFAULT) == TRUE) {
if(ffdormancy != TEL_AT_UDCONF_FFDRMNCY_VAL_DEFAULT) {
//SET command
ret = ciUdconf61Set(ffdormancy,atHandle);
cmdValid = TRUE;
}
else
{
//GET
ret = ciUdconf61Get(atHandle);
cmdValid = TRUE;
}
}
break;
case 62:
if (getExtValue
(parameter_values_p, 1, &ddtConfig, TEL_AT_UDCONF_DDTCNFG_VAL_MIN, TEL_AT_UDCONF_DDTCNFG_VAL_MAX,
TEL_AT_UDCONF_DDTCNFG_VAL_DEFAULT) == TRUE) {
if(ddtConfig != TEL_AT_UDCONF_DDTCNFG_VAL_DEFAULT) {
//SET command
ret = ciUdconf62Set(ddtConfig,atHandle);
cmdValid = TRUE;
}
else
{
//GET
ret = ciUdconf62Get(atHandle);
cmdValid = TRUE;
}
}
break;
case 70:
if (getExtValue
(parameter_values_p, 1, &posCap, TEL_AT_UDCONF_POSCAP_VAL_MIN, TEL_AT_UDCONF_POSCAP_VAL_MAX,
TEL_AT_UDCONF_POSCAP_VAL_DEFAULT) == TRUE) {
if(posCap != TEL_AT_UDCONF_POSCAP_VAL_DEFAULT) {
//SET command
ret = ciUdconf70Set(posCap,atHandle);
cmdValid = TRUE;
}
else
{
//GET
ret = ciUdconf70Get(atHandle);
cmdValid = TRUE;
}
}
break;
case 80:
if (getExtValue
(parameter_values_p, 1, &ciphoAlg, TEL_AT_UDCONF_CIPHOALG_VAL_MIN, TEL_AT_UDCONF_CIPHOALG_VAL_MAX,
TEL_AT_UDCONF_CIPHOALG_VAL_DEFAULT) == TRUE) {
if(ciphoAlg != TEL_AT_UDCONF_CIPHOALG_VAL_DEFAULT) {
//SET command
ret = ciUdconf80Set(ciphoAlg,atHandle);
cmdValid = TRUE;
}
else
{
//GET
ret = ciUdconf80Get(atHandle);
cmdValid = TRUE;
}
}
break;
case 81:
{
INT32 integrity;
if (getExtValue
(parameter_values_p, 1, &integrity, TEL_AT_UDCONF_INTEGRITY_VAL_MIN, TEL_AT_UDCONF_INTEGRITY_VAL_MAX,
TEL_AT_UDCONF_INTEGRITY_VAL_DEFAULT) == TRUE) {
if(integrity != TEL_AT_UDCONF_INTEGRITY_VAL_DEFAULT) {
//SET command
ret = ciUdconf81Set(integrity,atHandle);
cmdValid = TRUE;
}
else
{
//GET
ret = ciUdconf81Get(atHandle);
cmdValid = TRUE;
}
}
break;
}
case 100:
{
INT32 imsi;
if (getExtValue
(parameter_values_p, 1, &imsi, TEL_AT_UDCONF_IMSI_VAL_MIN, TEL_AT_UDCONF_IMSI_VAL_MAX,
TEL_AT_UDCONF_IMSI_VAL_DEFAULT) == TRUE) {
if(imsi != TEL_AT_UDCONF_IMSI_VAL_DEFAULT) {
//SET command
ret = ciUdconf100Set(imsi,atHandle);
cmdValid = TRUE;
}
else
{
//GET
ret = ciUdconf100Get(atHandle);
cmdValid = TRUE;
}
}
break;
}
default:
printf("*DCONF - command code %d not supported\n ", commandId);
break;
}
//check for extra parameters
if(Check3Param) {
if(getExtValue
(parameter_values_p, 2, &extraDefaultParam, TEL_AT_UDCONF_EXTRA_PARAM_VAL_MIN,
TEL_AT_UDCONF_EXTRA_PARAM_VAL_MAX,
TEL_AT_UDCONF_EXTRA_PARAM_VAL_DEFAULT) == TRUE) {
if(extraDefaultParam != TEL_AT_UDCONF_EXTRA_PARAM_VAL_DEFAULT ) {
//extra parameter found
cmdValid = FALSE;
}
}
}
}
break;
}
case TEL_EXT_GET_CMD: /*AT+UDCONF?*/
case TEL_EXT_TEST_CMD: /* AT+UDCONF=? */
default: /* AT+UDCONF */
break;
}
#endif
if (cmdValid == FALSE)
ret = CIRC_FAIL;
rc = HANDLE_RETURN_VALUE(ret);
return (rc);
}
RETURNCODE_T ciPARK(const utlAtParameterOp_T op, const char *command_name_p, const utlAtParameterValue_P2c parameter_values_p, const size_t num_parameters, const char *info_text_p, unsigned int *xid_p, void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
BOOL cmdValid = FALSE;
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);;
*xid_p = atHandle;
//DBGMSG(ciPARK, "ciPARK: atHandle = %d.\n", atHandle);
switch ( op ) {
case TEL_EXT_SET_CMD: /* AT*PARK= */
{
int on;
int roamingTimer;
int emergencyTimer;
int oosTimer;
if ( getExtValue( parameter_values_p, 0, &on, 0, 2, 0 ) == TRUE )
{
if(on == 1)
{
if ( getExtValue( parameter_values_p, 1, &roamingTimer, 0, 65535, 0 ) == TRUE )
{
if ( getExtValue( parameter_values_p, 2, &emergencyTimer, 0, 65535, 0 ) == TRUE )
{
if ( getExtValue( parameter_values_p, 3, &oosTimer, 0, 65535, 0 ) == TRUE )
{
cmdValid = TRUE;
//DBGMSG(ciPARK1, "roamingTimer:%d,emergencyTimer:%d,oosTimer:%d",
// roamingTimer, emergencyTimer, oosTimer);
}
}
}
}
else if(on == 0)
{
cmdValid = TRUE;
}
}
if(cmdValid == FALSE)
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
else
ret = DEV_SetPark(atHandle, on, roamingTimer, emergencyTimer, oosTimer);
break;
}
case TEL_EXT_GET_CMD: /* AT*PARK? */
{
ret = DEV_GetPark(atHandle);
break;
}
case TEL_EXT_TEST_CMD: /* AT*PARK=? */
case TEL_EXT_ACTION_CMD: /* AT*PARK */
default:
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return rc;
}
RETURNCODE_T ciTEMPTEST( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciTEMPTEST, "ciTEMPTEST: atHandle = %d.\n", atHandle);
switch ( op ) {
case TEL_EXT_TEST_CMD: /* AT*TEMPTEST=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*TEMPTEST:(0-1)");
break;
}
case TEL_EXT_SET_CMD: /* AT*TEMPTEST= */
{
int type;
if ( getExtValue( parameter_values_p, 0, &type, 0, 1, 0 ) == TRUE )
{
if(type == 0)
{
char Buf[30];
char str[10];
memset(str, 0, sizeof(str));
//read battery temperature
FILE *fp = fopen("/sys/class/power_supply/battery/temp", "rb");
if (fp != NULL)
{
fread(str, 1, 4, fp);
fclose(fp);
sprintf(Buf, "*TEMPTEST:%sC\n\r", str);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, Buf);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_UNKNOWN, NULL);
}
else if(type == 1)
{
//read rf temperature
ret = DEV_ReadRFTemperatureReq(atHandle, 0);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*TEMPTEST? */
case TEL_EXT_ACTION_CMD: /* AT*TEMPTEST */
default:
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return rc;
}
RETURNCODE_T ciFactoryReset( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciTEMPTEST, "ciZFactoryReset: atHandle = %d.\n", atHandle);
switch ( op ) {
case TEL_EXT_TEST_CMD: /* AT*FACTORY=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*ciZFactoryReset");
break;
}
case TEL_EXT_SET_CMD: /* AT*FACTORY= */
case TEL_EXT_GET_CMD: /* AT*FACTORY? */
case TEL_EXT_ACTION_CMD: /* AT*FACTORY */
{
ASR_flag tag;
int rs = get_asr_flag(&tag);
if(rs < 0)
{
WARNMSG(ciZFactoryReset, "read asr flag error\n");
ret = ATRESP( atHandle,ATCI_RESULT_CODE_ERROR,CME_UNKNOWN,NULL);
}
else
{
tag.Production_Mode_Flag = 0;
tag.ramdump[0] = RAMDUMPID;
tag.ramdump[1] = 0;
tag.cplog[0] = CPLOGID;
tag.cplog[1] = 0;
#ifdef CONFIG_EEH_FORCE_SILENT_RESET
tag.eehP[0] = EEHPID;
tag.eehP[1] = 0;
#endif
rs = write_asr_flag(&tag);
if (rs < 0) {
WARNMSG(ciZFactoryReset1, "write asr flag error\n");
ret = ATRESP( atHandle,ATCI_RESULT_CODE_ERROR,CME_UNKNOWN,NULL);
}
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
break;
}
default:
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
static unsigned int hexstr2ul(char *str)
{
unsigned int num = 0;
char *cp = str;
for (cp; *cp != '\0'; cp++)
{
if ((*cp >= '0') && (*cp <= '9')) num = (16 * num) + (*cp - '0');
else if ((*cp >= 'A') && (*cp <= 'F')) num = (16 * num) + (*cp - 'A') + 10;
else if ((*cp >= 'a') && (*cp <= 'f')) num = (16 * num) + (*cp - 'a') + 10;
else
ERRMSG(str2ul, "str is wrong");
}
return num;
}
static void getgwband(char *gw_mask, INT16 gwlen, UINT32 *gsmband, UINT32 *umtsband)
{
UINT32 gwl = 0, gwh = 0;
if (gwlen <= 8)
{
gwh = 0;
gwl = hexstr2ul(gw_mask);
}
else
{
gwl = hexstr2ul(&gw_mask[gwlen-8]);
char highra[9] = {0};
memset(highra, '\0', 9);
memcpy(highra, gw_mask, gwlen-8);
gwh = hexstr2ul(highra);
}
UINT32 tmp = (gwl & 0x3FFFFF);
*umtsband = ((gwh & 0x70000)>>10)|(gwl >> 22);
*gsmband = 0;
if(tmp & (1<<16)) //GSM450
*gsmband += 16;
if(tmp & (1<<17)) //GSM480
*gsmband += 32;
if(tmp & (1<<19)) //GSM850
*gsmband += 64;
if(tmp & (1<<8)) //EGSM 900
*gsmband += 8;
if(tmp & (1<<9)) //PGSM 900
*gsmband += 1;
if(tmp & (1<<7)) //DCS 1800
*gsmband += 2;
if(tmp & (1<<21)) //PCS 1900
*gsmband += 4;
}
/************************************************************************************
* F@: ciACONFIG - GLOBAL API for AT+ACONFIG command
*
*/
RETURNCODE_T ciACONFIG( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
int obmdlset = 0;
UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
*xid_p = atHandle;
char config_str[201]={0};
int config_strlen = 0, err = 0;
CHAR returnStr[32] = {0};
switch(op)
{
case TEL_EXT_SET_CMD: /* AT+ACONFIG= */
{
if(getExtString(parameter_values_p, 0, config_str, 200, &config_strlen, NULL) == TRUE)
{
if(config_strlen == 0)
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
else
{
int rc, pipe, pipe_changed = 0;
//DBGMSG(ciACONFIG, "cfg:%s\n", config_str);
ASR_flag tag;
rc = get_asr_flag(&tag);
if(rc < 0)
{
WARNMSG(ciACONFIG1, "read asr flag error\n");
}
else
{
pipe = tag.pipe[1];
obmdlset = parseConfigString(config_str, config_strlen, (char*)&tag);
if (pipe != tag.pipe[1])
pipe_changed = 1;
}
rc = write_asr_flag(&tag);
if (rc < 0)
WARNMSG(ciACONFIG2, "write asr flag error\n");
if(rc < 0)
ret = ATRESP( atHandle,ATCI_RESULT_CODE_ERROR,0,NULL);
else
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
if (pipe_changed) {
CHAR returnStr[30] = {0};
if (pipe) {
executeShellCMD("cp -fp /etc/config/dhcp_mifi /etc/config/dhcp", returnStr);
executeShellCMD("cp -fp /etc/config/network_mifi /etc/config/network", returnStr);
} else {
executeShellCMD("cp -fp /etc/config/dhcp /etc/config/dhcp_mifi", returnStr);
executeShellCMD("cp -fp /etc/config/network /etc/config/network_mifi", returnStr);
}
executeShellCMD("sync && reboot", returnStr);
}
if (obmdlset == 1)
{
//system("reboot");
memset(returnStr, 0x00, sizeof(returnStr));
executeShellCMD("reboot", returnStr);
}
else if (obmdlset == 2) //set RDUP=0
{
memset(returnStr, 0x00, sizeof(returnStr));
err = executeShellCMD("echo 0 > /proc/sys/kernel/rdup", returnStr);
ERRMSG(ciACONFIG000, "%s: err=%d\n", __FUNCTION__, err);
}
else if (obmdlset == 3) //set RDUP=1
{
memset(returnStr, 0x00, sizeof(returnStr));
err = executeShellCMD("echo 1 > /proc/sys/kernel/rdup", returnStr);
ERRMSG(ciACONFIG001, "%s: err=%d\n", __FUNCTION__, err);
}
else if (obmdlset == 4) //set CPLOG=0
{
DEV_SetIMLConfigReq(atHandle, 12, 0, NULL); //disable cp log
}
else if (obmdlset == 5) //set CPLOG=1
{
DEV_SetIMLConfigReq(atHandle, 13, 0, NULL); //enable cp log
}
else
{
//nothing to be do
}
}
}
else
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
}
break;
case TEL_EXT_GET_CMD: /* AT+ZCONFIG? */
{
ASR_flag tag;
rc = get_asr_flag(&tag);
sprintf(config_str, "PID=%X,VID=%X,IMSD=%d,PIPE=%d,FAST=%d,RDUP=%d,NOCP=%d,CPLOG=%d",
tag.pid[0] == PIDID?tag.pid[1]:0,
tag.vid[0] == VIDID?tag.vid[1]:0,
tag.imsd[0] == IMSDID?tag.imsd[1]:0,
tag.pipe[0] == PIPEID?tag.pipe[1]:0,
tag.fast[0] == FASTID?tag.fast[1]:0,
tag.ramdump[0] == RAMDUMPID?tag.ramdump[1]:0,
tag.nocp[0] == NOCPID?tag.nocp[1]:0,
tag.cplog[0] == CPLOGID?tag.cplog[1]:0);
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,config_str);
break;
}
default:
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
const struct blobmsg_policy ims_status_policy[] ={
[0] = {
.name = "response_status",
.type = BLOBMSG_TYPE_STRING,
},
[1] = {
.name = "normal_status",
.type = BLOBMSG_TYPE_STRING,
},
[2] = {
.name = "emergency_status",
.type = BLOBMSG_TYPE_STRING,
},
};
void GetIMSStatus(struct ubus_request *req, int type, struct blob_attr *msg)
{
UNUSEDPARAM(type);
struct blob_attr *tb[3];
struct blob_attr *cur;
char str[50];
char *resp;
char *normal;
char *emergency;
UINT32 atHandle = *(int *)req->priv;
int rc;
//DBGMSG(GetIMSStatus, "GetIMSStatus\n");
/*parsing blob to be accessed easily with tb array - parse "1" argument*/
rc = blobmsg_parse(ims_status_policy, 3, tb, blob_data(msg), blob_len(msg));
if (rc < 0) {
ERRMSG(GetIMSStatus0, "GetIMSStatus: blobmsg_parse fail\n");
ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, CME_UNKNOWN, NULL);
return;
}
/*parse first parameter*/
cur = tb[0];
if (!cur) {
ERRMSG(GetIMSStatus1, "GetIMSStatus: missing parameter\n");
ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, CME_UNKNOWN, NULL);
return;
}
resp = blobmsg_get_string(cur);
//DBGMSG(GetIMSStatus2, "GetIMSStatus, resp:%s\n", resp);
if (strcmp(resp, "OK")==0) {
normal = blobmsg_get_string(tb[1]);
emergency = blobmsg_get_string(tb[2]);
sprintf(str, "+IMSFUNC: 1,%d,%d", strcmp(normal, "TRUE")==0?1:0,
strcmp(emergency, "TRUE")==0?1:0);
}
else
sprintf(str, "+IMSFUNC: 0,0,0");
ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, str);
return;
}
/************************************************************************************
* F@: ciIMSFUNC - GLOBAL API for AT+IMSFUNC command
*
*/
RETURNCODE_T ciIMSFUNC( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
*xid_p = atHandle;
TelAtParserID origParserId = *(TelAtParserID *)arg_p;
switch(op)
{
case TEL_EXT_SET_CMD: /* AT+IMSFUNC= */
{
int enable = 0;
int rc = 0;
if (getExtValue( parameter_values_p, 0, &enable, 0, 1, 0 ) == TRUE )
{
//ubus call
struct blob_buf outBlob;
memset(&outBlob, 0, sizeof(outBlob));
blob_buf_init(&outBlob, 0);
blobmsg_add_string(&outBlob, "status", enable==0?"0":"1");
if (invoke_noreply_ril(origParserId, "ims", "ims_poweron", outBlob.head) == 0) {
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
blob_buf_free(&outBlob);
}
}
break;
case TEL_EXT_GET_CMD: /* AT+IMSFUNC? */
{
int val = invoke_reply_data_cb(origParserId, "ims", "ims_status_query", NULL,
(ubus_data_handler_t *)GetIMSStatus, &atHandle, 2000);
if (val == UBUS_STATUS_OK)
ret = CIRC_SUCCESS;
//DBGMSG(ciIMSFUNC2, "imsfuc get ret:%d", val);
}
break;
default:
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciCGMR - GLOBAL API for AT+ZVN command
*
*/
RETURNCODE_T ciZVN( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciZVN, "ciZVN: atHandle = %d.\n", atHandle);
char respbuf[MAX_INTERNALREVISION_ID_LENGTH];
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_ACTION_CMD: /* AT+ZVN */
{
#ifdef MBTK_AT_SUPPORT
sprintf(respbuf, "%s", MBTK_DEVICES_REVISION);
#else
sprintf(respbuf, "%s", VENDOR_SW_VERSION);
#endif
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, respbuf);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#ifdef CUSTZ
RETURNCODE_T ciZNLOCKBAND( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 gsmband, umtsband, eutranhband, eutranlband, gwl, gwh;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciZNLOCKBAND, "ciZNLOCKBAND: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+ZNLOCKBAND? */
{
ret = DEV_GetZNLOCKBANDReq(atHandle);
break;
}
case TEL_EXT_SET_CMD: /* AT+ZNLOCKBAND= */
{
BOOL cmdValid = FALSE;
int lte_band_enable = 0;
int gw_band_enable = 0;
char lte_mask[17] = {0};
char gw_mask[17] = {0};
INT16 ltelen = 0;
INT16 gwlen = 0;
if ( getExtValue( parameter_values_p, 0, &lte_band_enable, 0, 1, 0 ) == TRUE )
{
if ( getExtValue( parameter_values_p, 1, &gw_band_enable, 0, 1, 0 ) == TRUE )
{
if ( getExtString( parameter_values_p, 2, &lte_mask, 17, &ltelen, NULL ) == TRUE )
{
if ( getExtString( parameter_values_p, 3, &gw_mask, 17, &gwlen, NULL ) == TRUE )
{
//DBGMSG(ciZNLOCKBAND0, "ciZNLOCKBAND0:%d,%d,%s,%s\n", lte_band_enable,
// gw_band_enable, lte_mask, gw_mask);
cmdValid = TRUE;
if (lte_band_enable == 1 && gw_band_enable == 1)
{
if (ltelen <= 8)
{
eutranhband = 0;
eutranlband = hexstr2ul(lte_mask);
}
else
{
eutranlband = hexstr2ul(&lte_mask[ltelen-8]);
char highra[9] = {0};
memset(highra, '\0', 9);
memcpy(highra, lte_mask, ltelen-8);
eutranhband = hexstr2ul(highra);
}
getgwband(gw_mask, gwlen, &gsmband, &umtsband);
ret = DEV_SetBandModeReqExt(atHandle, CI_DEV_NW_UMTS_LTE, CI_DEV_NW_UMTS_LTE, gsmband, umtsband, eutranhband, eutranlband,
CI_DEV_SET_BAND_ROAMING_NOT_CHANGE, CI_DEV_SET_BAND_ANY_SERVICE, 0, 0, 0);
}
else if (lte_band_enable == 1)
{
if (ltelen <= 8)
{
eutranhband = 0;
eutranlband = hexstr2ul(lte_mask);
}
else
{
eutranlband = hexstr2ul(&lte_mask[ltelen-8]);
char highra[9] = {0};
memset(highra, '\0', 9);
memcpy(highra, lte_mask, ltelen-8);
eutranhband = hexstr2ul(highra);
}
ret = DEV_SetBandModeReqExt(atHandle, CI_DEV_NW_LTE, CI_DEV_NW_LTE, 0, 0, eutranhband, eutranlband,
CI_DEV_SET_BAND_ROAMING_NOT_CHANGE, CI_DEV_SET_BAND_ANY_SERVICE, 0, 0, 0);
}
else if (gw_band_enable == 1)
{
getgwband(gw_mask, gwlen, &gsmband, &umtsband);
ret = DEV_SetBandModeReqExt(atHandle, CI_DEV_NW_UMTS, CI_DEV_NW_UMTS, gsmband, umtsband, 0, 0,
CI_DEV_SET_BAND_ROAMING_NOT_CHANGE, CI_DEV_SET_BAND_ANY_SERVICE, 0, 0, 0);
}
else
cmdValid = FALSE;
}
}
}
}
if(!cmdValid)
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#if defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
extern char ft_delim1[];
void parseNrBandBitmap(CHAR *bandStr, UINT32 *nrFr1BandBitmap, UINT32* nrFr2BandBitmap)
{
char* p = NULL;
int band =0;
int bitMapNum =0;
if(bandStr == NULL)
return;
if((nrFr1BandBitmap == NULL) || (nrFr2BandBitmap == NULL) )
return;
//ERRMSG(parseNrBandBitmap0, "%s: bandStr %s", __FUNCTION__, bandStr);
*nrFr2BandBitmap = 0;
memset(nrFr1BandBitmap, 0, CI_DEV_NR_FR1_BAND_LIST_NUM<<2);
p = strsep(&bandStr, ft_delim1);
while(1)
{
if(p && strlen(p) && strcmp(p," "))
{
band = atoi(p);
bitMapNum = band >> 5;
//ERRMSG(parseNrBandBitmap1, "%s: band %d, bitMapNum %d", __FUNCTION__, band, bitMapNum);
// ERRMSG(parseNrBandBitmap2, "%s: nrFr1BandBitmap[0] 0x%X, nrFr1BandBitmap[1] 0x%X, nrFr1BandBitmap[2] 0x%X, nrFr1BandBitmap[3] 0x%X, nrFr2BandBitmap 0x%X", __FUNCTION__, nrFr1BandBitmap[0], nrFr1BandBitmap[1], nrFr1BandBitmap[2], nrFr1BandBitmap[3], *nrFr2BandBitmap);
if(band < 128)
{
// ERRMSG(parseNrBandBitmap3, "%s: %d, %d", __FUNCTION__, band - ((band>>5)<<5), (1 << ((band - ((band>>5)<<5))-1)));
if(bitMapNum < CI_DEV_NR_FR1_BAND_LIST_NUM)
nrFr1BandBitmap[bitMapNum] += (1 << ((band - ((band>>5)<<5))-1));
}else
{
//ERRMSG(parseNrBandBitmap4, "%s: %d", __FUNCTION__, 1 << (band - 129));
*nrFr2BandBitmap += 1 << (band - 129);
}
//ERRMSG(parseNrBandBitmap5, "%s: nrFr1BandBitmap[0] 0x%X, nrFr1BandBitmap[1] 0x%X, nrFr1BandBitmap[2] 0x%X, nrFr1BandBitmap[3] 0x%X, nrFr2BandBitmap 0x%X", __FUNCTION__, nrFr1BandBitmap[0], nrFr1BandBitmap[1], nrFr1BandBitmap[2], nrFr1BandBitmap[3], *nrFr2BandBitmap);
p = strsep(&bandStr, ft_delim1);
}
else
break;
}
}
RETURNCODE_T ciZNLOCKNRBAND( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
CHAR bandStr[202] = {0};
int bandStrLen = 0;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+ZNLOCKNRBAND? */
{
ret = DEV_GetZNLOCKNRBANDReq(atHandle);
break;
}
case TEL_EXT_SET_CMD: /* AT+ZNLOCKNRBAND= */
{
BOOL cmdValid = FALSE;
int type = 0;
CiBitRange nrFr1BandBitmap[CI_DEV_NR_FR1_BAND_LIST_NUM];
CiBitRange nrFr2BandBitmap = 0;
memset(nrFr1BandBitmap, 0, CI_DEV_NR_FR1_BAND_LIST_NUM<<2);
if ( getExtValue( parameter_values_p, 0, &type, 0, 0, 0 ) == TRUE )
{
if( getExtString( parameter_values_p, 1, (CHAR *)bandStr, 200, &bandStrLen, NULL ) == TRUE )
{
cmdValid = TRUE;
parseNrBandBitmap(bandStr, nrFr1BandBitmap,&nrFr2BandBitmap);
}
}
if(!cmdValid)
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
else
{
ret = DEV_SetBandModeReq(atHandle,
CI_DEV_NW_LTE_NR,
CI_DEV_NW_LTE_NR,
0,
0,
0,
0,
&nrFr1BandBitmap[0],
nrFr2BandBitmap,
CI_DEV_SET_BAND_ROAMING_NOT_CHANGE,
CI_DEV_SET_BAND_ANY_SERVICE,
0,
0);
}
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
RETURNCODE_T ciZCELLINFO(const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
UNUSEDPARAM(arg_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
switch ((int)op) {
case TEL_EXT_GET_CMD: /* AT+ZCELLINFO?*/
{
ret = DEV_GetZCELLINFO(atHandle);
break;
}
case TEL_EXT_TEST_CMD:
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0,
"+ZCELLINFO:SA:Global Cell ID,PCI,band,arfcnr\r\nNSA:Global Cell ID,lte PCI,band,dl Earfcn,nr5g pci,band,arfcn,nr5g bandwidth\r\nLTE:Global Cell ID,Physical Cell ID,Cell Band,DL Earfcn\r\nWCDMA:LAC,Cell ID,Cell Band\r\nGSM:LAC,Cell ID,Cell Band\r\n");
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciZDOGREF - GLOBAL API for GCF AT+ZDOGREF command
*
*/
static int zdogrefmode = 0;
RETURNCODE_T ciZDOGREF( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
char atRspBuf[50];
*xid_p = atHandle;
//DBGMSG(cistarCTZR, "ciZDOGREF: atHandle = %d.\n", atHandle);
switch (op)
{
case TEL_EXT_GET_CMD: /* AT+ZDOGREF? */
{
sprintf(atRspBuf, "+ZDOGREF: %d", zdogrefmode);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, atRspBuf);
break;
}
case TEL_EXT_SET_CMD: /* AT+ZDOGREF */
{
int mode = 0;
if(getExtValue(parameter_values_p, 0, &mode, 0, 65535, 0) == TRUE)
{
if (mode == 0)
{
zdogrefmode = mode;
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, "+ZDOGREF: disabled");
}
else if (mode == 1)
{
zdogrefmode = mode;
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, "+ZDOGREF:enabled");
}
else if (mode == 2)
{
sprintf(atRspBuf, "+ZDOGREF: %d", zdogrefmode);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, atRspBuf);
}
else
{
zdogrefmode = mode;
sprintf(atRspBuf, "+ZDOGREF: %d", zdogrefmode);
ATRESP(1, 0, 0, atRspBuf);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, NULL, NULL);
}
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciZATNUM - GLOBAL API for GCF AT+ZATNUM command
*
*/
RETURNCODE_T ciZATNUM( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(cistarCTZR, "ciZATNUM: atHandle = %d.\n", atHandle);
switch (op)
{
case TEL_EXT_GET_CMD: /* AT+ZATNUM? */
{
char atRspBuf[50];
sprintf(atRspBuf, "+ZATNUM: %d", gNumofAT);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, NULL, atRspBuf);
break;
}
case TEL_EXT_ACTION_CMD: /* AT+ZATNUM */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciGETEL - GLOBAL API for GCF AT+GEFLAG command
*
*/
RETURNCODE_T ciGEFLAG( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
CHAR returnStr[20] = {0};
*xid_p = atHandle;
switch (op)
{
case TEL_EXT_GET_CMD: /* AT+GEFLAG? */
{
// system("uci get wan.getelcom>/tmp/getelcom");
executeShellCMD("uci get wan.getelcom>/tmp/getelcom", returnStr);
FILE * fp = fopen("/tmp/getelcom","r");
if (fp)
{
char Buf[20];
char str[2];
memset(str, 0, sizeof(str));
int re = fread(str, 1, 1, fp);
fclose(fp);
if (re > 0)
{
sprintf(Buf, "+GEFLAG:%d\n\r", atoi(str));
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, Buf);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, "Not Found Item");
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT+GEFLAG */
{
int mode;
if(getExtValue(parameter_values_p, 0, &mode, 0, 1, 0) == TRUE)
{
char buf[100];
sprintf(buf, "uci set wan.getelcom=%d", mode);
//system(buf);
//system("uci commit wan");
executeShellCMD(buf, returnStr);
executeShellCMD("uci commit wan", returnStr);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, NULL, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciZCFG - GLOBAL API for GCF AT+ZCFG command
*
*/
RETURNCODE_T ciZCFG( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
switch (op)
{
case TEL_EXT_GET_CMD: /* AT+ZCFG? */
{
ret = Dev_QueryZCFG(atHandle, 0xFF);
break;
}
case TEL_EXT_SET_CMD: /* AT+ZCFG */
{
int featureId;
int featureValue;
if(getExtValue(parameter_values_p, 0, &featureId, 0, 255, 0) == TRUE)
{
if (parameter_values_p[1].is_default)
{
//query feature value
ret = Dev_QueryZCFG(atHandle, (UINT32)featureId);
break;
}
if(getExtValue(parameter_values_p, 1, &featureValue, 0, 0x7FFFFFFF, 0) == TRUE)
{
//set feature value
ret = Dev_SetZCFG(atHandle, (UINT32)featureId, (UINT32)featureValue);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciZROAM - GLOBAL API for GCF AT+ZROAM command
*
*/
RETURNCODE_T ciZROAM( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
switch (op)
{
case TEL_EXT_GET_CMD: /* AT+ZROAM? */
{
ret = Dev_QueryZROAM(atHandle);
break;
}
case TEL_EXT_SET_CMD: /* AT+ZROAM */
{
char plmn[10];
INT16 len;
int pdptype;
memset(plmn, 0, sizeof(plmn));
if(getExtString(parameter_values_p, 0, plmn, 9, &len, NULL) == TRUE)
{
//DBGMSG(ciZROAM, "%s: plmn:%s", __func__, plmn);
char tmp[4];
memset(tmp, 0, sizeof(tmp));
memcpy(tmp, plmn, 3);
UINT16 mcc = (UINT16)str2hex32(tmp);
UINT16 mnc = (UINT16)str2hex32(plmn+3);
UINT8 lenofmnc = len - 3;
if (parameter_values_p[1].is_default)
{
//delete
ret = Dev_DeleteZROM(atHandle, mcc, mnc, lenofmnc);
break;
}
if(getExtValue(parameter_values_p, 1, &pdptype, 1, 3, 1) == TRUE)
{
//set value
ret = Dev_SetZROM(atHandle, mcc, mnc, lenofmnc, pdptype);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciZDHCPLEASE - GLOBAL API for GCF AT+ZDHCPLEASE command
*
*/
RETURNCODE_T ciZDHCPLEASE( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
CHAR returnStr[20] = {0};
*xid_p = atHandle;
switch (op)
{
case TEL_EXT_GET_CMD: /* AT+ZDHCPLEASE? */
{
//system("uci get dhcp.lan.leasetime>/tmp/dhcpleasetime");
executeShellCMD("uci get dhcp.lan.leasetime>/tmp/dhcpleasetime", returnStr);
FILE * fp = fopen("/tmp/dhcpleasetime","r");
if (fp)
{
char Buf[50];
char str[20];
memset(str, 0, sizeof(str));
if (fgets(str, sizeof(str), fp) == NULL)
{
fclose(fp);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, "Not Found Item");
}
else
{
int value = 0;
char *p = str;
sscanf(str, "%d", &value);
while (*p != '\0' && isdigit(*p))
p++;
if (*p == 'h')
value *= 3600;
else if (*p == 'd')
value *= 3600*24;
else if (*p == 'm')
value *= 3600*24*30;
sprintf(Buf, "+ZDHCPLEASE:%d", value);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, Buf);
fclose(fp);
}
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT+ZDHCPLEASE= */
{
unsigned int time;
if(getExtUValue(parameter_values_p, 0, &time, 0, 0xFFFFFFFF, 0) == TRUE)
{
char buf[100];
if (time == 0)
sprintf(buf, "uci set dhcp.lan.leasetime=7200");
else
sprintf(buf, "uci set dhcp.lan.leasetime=%d", time);
//system(buf);
//system("/etc/init.d/dnsmasq restart");
executeShellCMD(buf, returnStr);
executeShellCMD("/etc/init.d/dnsmasq restart", returnStr);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, NULL, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciCGMR - GLOBAL API for AT*ZCGMR command
*
*/
RETURNCODE_T ciZCGMR( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
char buf[200];
char printbuf[300] = {0};
FILE *fp = fopen("/etc/mversion","r");
if(NULL == fp){
WARNMSG(ciZCGMR,"open file failed!");
return false;
}
memset(buf, 0, sizeof(buf));
fgets(buf,200,fp);
buf[strlen(buf) - 1] = '\0';
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
//DBGMSG(ciCGMR, "ciZCGMR: atHandle = %d.\n", atHandle);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_ACTION_CMD: /* AT*ZCGMR */
{
sprintf(printbuf, "*ZCGMR: \"%s\"", buf);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, printbuf);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
fclose(fp);
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
/************************************************************************************
* F@: ciSTRESS - GLOBAL API for GCF AT+STRESS command
*
*/
RETURNCODE_T ciSTRESS( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
char atRspBuf[50];
*xid_p = atHandle;
//DBGMSG(ciSTRESS, "ciSTRESS: atHandle = %d.\n", atHandle);
switch (op)
{
case TEL_EXT_GET_CMD: /* AT+STRESS? */
{
ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case TEL_EXT_SET_CMD: /* AT+STRESS */
{
char p1[10],p2[10];
INT16 p1len = 0;
INT16 p2len = 0;
if(getExtString(parameter_values_p, 0, &p1, 10, &p1len, "0") == TRUE)
{
if(getExtString(parameter_values_p, 1, &p2, 10, &p2len, "0") == TRUE)
{
pid_t pid;
int res = 0;
int error = 0;
if ((pid = fork()) < 0)
{
DBGMSG(ciSTRESS1, "fork error\n");
error = 1;
}
else if (pid == 0)
{
if (execl("/sbin/stresstest.sh", "stresstest.sh", p1, p2, NULL) < 0)
{
WARNMSG(ciSTRESS2, "ciSTRESS: execl erro\n");
error = 2;
}
}
if (wait(&res) != pid)
{
WARNMSG(ciSTRESS3, "ciSTRESS: wait erro\n");
error = 3;
}
if (error == 0 && WIFEXITED(res))
{
if (WEXITSTATUS(res) == 0)
sprintf(atRspBuf, "+STRESS: PASS");
else
sprintf(atRspBuf, "+STRESS: FAIL");
}
else
sprintf(atRspBuf, "+STRESS: %d", error);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, atRspBuf);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciSULOG - GLOBAL API for GCF AT+SULOG command
*
*/
RETURNCODE_T ciSULOG( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
char atRspBuf[50];
*xid_p = atHandle;
//DBGMSG(cistarCTZR, "ciSULOG: atHandle = %d.\n", atHandle);
switch (op)
{
case TEL_EXT_SET_CMD: /* AT+SULOG */
{
int mode = 0;
CHAR returnStr[20] = {0};
if(getExtValue(parameter_values_p, 0, &mode, 0, 1, 0) == TRUE)
{
if (mode == 0)
{
//system("sulog -d 0");
executeShellCMD("sulog -d 0", returnStr);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, NULL, NULL);
}
else if (mode == 1)
{
//system("sulog -d 1");
executeShellCMD("sulog -d 1", returnStr);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, NULL, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciMEDCR - GLOBAL API for AT+MEDCR command
*
* position 8, opt for specific IOT without 4G to fasten registration, #468.
* position 9, opt for no detach/attach for AT*BAND initated 23G NW mode change, #
*
*/
RETURNCODE_T ciMEDCR( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(num_parameters);
TelAtParserID sAtpIndex = * (TelAtParserID *) arg_p;
UINT32 atHandle = MAKE_AT_HANDLE( sAtpIndex );
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
int flag, position, value;
//DBGMSG(ciMEDCR, "%s: sAtpIndex - %x, atHandle - %x", __func__, sAtpIndex, atHandle);
*xid_p = atHandle;
switch(op)
{
case TEL_EXT_SET_CMD:
if( getExtValue( parameter_values_p, 0, &flag, 0, 1, 0) == FALSE )
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
#if defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
if( getExtValue( parameter_values_p, 1, &position, 0, 65535, 8) == FALSE )
#else
if( getExtValue( parameter_values_p, 1, &position, 0, 255, 8) == FALSE )
#endif
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
if( getExtValue( parameter_values_p, 2, &value, 0, 255, 1) == FALSE )
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
if(flag == 0) { //set
ret = DEV_SetMEDCR(atHandle, (UINT16)position, (UINT8)value);
} else if(flag == 1) { //get
ret = DEV_GetMEDCR(atHandle, (UINT16)position);
}
break;
case TEL_EXT_GET_CMD:
case TEL_EXT_TEST_CMD:
//coverity[string_null:SUPPRESS]
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+MEDCR=<flag>,<position>,<value>");
break;
default:
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return rc;
}
/************************************************************************************
* F@: ciSIMLOCKFUSE - GLOBAL API for GCF AT+SIMLOCKFUSE command
*
*/
RETURNCODE_T ciSIMLOCKFUSE( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
UINT32 flag;
char param[16];
INT16 param_len;
*xid_p = atHandle;
switch (op)
{
case TEL_EXT_GET_CMD: /* AT+SIMLOCKFUSE? */
{
char Buf[50];
//get sim lock fuse status
flag = SIM_ReadLockFuse();
sprintf(Buf, "+SIMLOCKFUSE:%d", flag);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, Buf);
break;
}
case TEL_EXT_SET_CMD: /* AT+SIMLOCKFUSE=BURN */
{
memset(param, 0, sizeof(param));
if (getExtString(parameter_values_p, 0, param, sizeof(param), &param_len, NULL) != TRUE)
{
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
break;
}
if (((!strcmp(param, "BURN")) || (!strcmp(param, "burn"))) && (param_len == strlen("BURN")))
{
if (SIM_ProgLockFuse())
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CMS_UNKNOWN_ERROR, NULL);
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciAntennaTuner - GLOBAL API for GCF AT*ANTTUNER -command
*
*/
RETURNCODE_T ciAntennaTuner( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciAntennaTuner, "ciAntennaTuner: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_TEST_CMD: /* AT*ANTTUNER=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,(char *)"*ANTTUNER: (0-3)\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT*ANTTUNER= */
{
int Val = 0;
if ( getExtValue( parameter_values_p, 0, &Val, TEL_AT_ANTTUNER_0_VAL_MIN, TEL_AT_ANTTUNER_0_VAL_MAX, TEL_AT_ANTTUNER_0_VAL_DEFAULT ) == TRUE )
{
ret = DEV_SetAntennaTuner(atHandle, (UINT8)Val);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*ANTTUNER? */
case TEL_EXT_ACTION_CMD: /* AT*ANTTUNER */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciDdrFreq - GLOBAL API for GCF AT*DDRFREQ -command
*
*/
int gDdrFreqMode = 0;
RETURNCODE_T ciDdrFreq( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
CHAR returnStr[20] = {0};
*xid_p = atHandle;
//DBGMSG(ciAntennaTuner, "ciDdrFreq: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_TEST_CMD: /* AT*DDRFREQ=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,(char *)"*DDRFREQ: (0,1)\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT*DDRFREQ= */
{
int mode = 0;
if ( getExtValue( parameter_values_p, 0, &mode, TEL_AT_DDRFREQ_0_VAL_MIN, TEL_AT_DDRFREQ_0_VAL_MAX, TEL_AT_DDRFREQ_0_VAL_DEFAULT ) == TRUE )
{
gDdrFreqMode = mode;
if(!mode)
//system("echo cfun0ddr533 > /sys/power/ddr_devfreq_min_pm_unqos"); //clear high-freq 533
executeShellCMD("echo cfun0ddr533 > /sys/power/ddr_devfreq_min_pm_unqos", returnStr);
else
//system("echo cfun0ddr533 533000 > /sys/power/ddr_devfreq_min_pm_qos"); //set high-freq 533
executeShellCMD("echo cfun0ddr533 533000 > /sys/power/ddr_devfreq_min_pm_qos", returnStr);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, NULL, NULL);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*DDRFREQ? */
{
char Buf[16];
sprintf(Buf, "*DDRFREQ:%d", gDdrFreqMode);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, Buf);
break;
}
case TEL_EXT_ACTION_CMD: /* AT*DDRFREQ */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciSocTemp - GLOBAL API for AT*SOCTEMP command
*
*/
RETURNCODE_T ciSocTemp( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
int returnValue=0;
CHAR respStr[20] = "*SOCTEMP:";
CHAR returnStr[20] = {0};
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_ACTION_CMD: /* AT*SOCTEMP */
{
executeShellCMD("cat /sys/class/thermal/thermal_zone0/temp", returnStr);
strcat(respStr, returnStr);
//DBGMSG(ciSocTemp1, "SOCTEMP: %s\n", returnStr);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, respStr);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#if defined(ATCMD_UNIFY_CI) || defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
/************************************************************************************
* F@: ciDelFbPlmn - GLOBAL API for GCF AT*DELFBPLMN -command
*
*/
RETURNCODE_T ciDelFbPlmn( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//INFOMSG(ciDelFbPlmn, "ciDelFbPlmn: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_TEST_CMD: /* AT*DELFBPLMN=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,(char *)"*DELFBPLMN: (0-3)\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT*DELFBPLMN= */
{
int type;
if ( getExtValue(parameter_values_p, 0, &type, TEL_AT_DELFBPLMN_0_VAL_MIN, TEL_AT_DELFBPLMN_0_VAL_MAX, TEL_AT_DELFBPLMN_0_VAL_DEFAULT) == TRUE)
{
ret = DEV_DelFbPlmn(atHandle, (UINT8)type);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*DELFBPLMN? */
case TEL_EXT_ACTION_CMD: /* AT*DELFBPLMN */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciComFeature - GLOBAL API for GCF AT*COMFEATURE -command
*
*/
RETURNCODE_T ciComFeature( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*COMFEATURE= */
{
int id = 0;
int cmd = 0;
int index = 0;
INT16 len = 0;
CHAR data[TEL_AT_COMFEATURE_2_DATA_MAX_LEN + ATCI_NULL_TERMINATOR_LENGTH];
CHAR arfcnList[TEL_AT_COMFEATURE_2_DATA_MAX_LEN + ATCI_NULL_TERMINATOR_LENGTH];
INT16 arfcnlen = 0;
BOOL cmdValid = FALSE;
if ( getExtValue( parameter_values_p, 0, &cmd, TEL_AT_COMFEATURE_0_CMD_VAL_MIN,TEL_AT_COMFEATURE_0_CMD_VAL_MAX, TEL_AT_COMFEATURE_0_CMD_VAL_DEFAULT ) == TRUE )
{
if ( getExtValue( parameter_values_p, 1, &id, TEL_AT_COMFEATURE_1_ID_VAL_MIN,TEL_AT_COMFEATURE_1_ID_VAL_MAX, TEL_AT_COMFEATURE_1_ID_VAL_DEFAULT ) == TRUE )
{
if(getExtString(parameter_values_p, 2, data, TEL_AT_COMFEATURE_2_DATA_MAX_LEN, &len, TEL_AT_COMFEATURE_2_DATA_DEFAULT) == TRUE)
{
if ( getExtValue( parameter_values_p, 3, &index, TEL_AT_COMFEATURE_3_INDEX_VAL_MIN,TEL_AT_COMFEATURE_3_INDEX_VAL_MAX, TEL_AT_COMFEATURE_3_INDEX_VAL_DEFAULT) == TRUE )
{
if (getExtString(parameter_values_p, 4, arfcnList, TEL_AT_COMFEATURE_2_DATA_MAX_LEN, &arfcnlen, TEL_AT_COMFEATURE_2_DATA_DEFAULT) == TRUE)
cmdValid = TRUE;
}
}
}
}
if (cmdValid == TRUE)
{
if (cmd == DEV_COMMON_CMD_GET) //get operation
{
#if defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
if (id == CI_DEV_FT_OPERATION_ARFCN_LIST)
{
if (parameter_values_p[2].is_default)
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
else
ret = Dev_GetComFeature(atHandle, (UINT16)id, index, data);
}
else
#endif
{
if (parameter_values_p[3].is_default) //query all
ret = Dev_GetComFeature(atHandle, (UINT16)id, 65535, data);
else
ret = Dev_GetComFeature(atHandle, (UINT16)id, (UINT32)(index-1), data); //query one
}
}
else if((cmd == DEV_COMMON_CMD_SET) || (cmd == DEV_COMMON_CMD_DEL))
{
#if defined(ATCMD_UNIFY_CI)
if(devVersion > 0x0001)
ret = Dev_SetComFeature(atHandle, (UINT8)cmd, (UINT16)id, data, index, arfcnList);
else
ret = Dev_SetComFeature_v0001(atHandle, (UINT8)cmd, (UINT16)id, data, index, arfcnList);
#else
ret = Dev_SetComFeature(atHandle, (UINT8)cmd, (UINT16)id, data, index, arfcnList);
#endif
}
else if ((cmd == DEV_COMMON_CMD_INSERT) || (cmd == DEV_COMMON_CMD_UPDATE))
{
//id == 13
ret = Dev_SetComFeature(atHandle, (UINT8)cmd, (UINT16)id, data, index, arfcnList);
}
else
DBGMSG(ciComFeature1,"%s: invalid cmd", __FUNCTION__);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*COMFEATURE? */
case TEL_EXT_ACTION_CMD: /* AT*COMFEATURE */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
#if defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
#ifdef ENABLE_WIFI_SCAN
static UINT8 g_wifi_curr_option = 0;
//ICAT EXPORTED ENUM
typedef enum {
Ps_High =0,
Wifi_High
}ScanPriority_te;
//ICAT EXPORTED STRUCT
typedef struct{
UINT8 ScanRoundNum; //from 1 to 3. and the default value is 3
UINT8 ScanMaxBssidNum; //from 4 to 10, and the default value is 5
UINT8 ScanTimeout; // uint:second and the default value is 25s
ScanPriority_te ScanPriority; //the prioprity of PS and wifi
}MMWFScanStartReq_ts;
MMWFScanStartReq_ts gWifiScanCfg = {3,5,25,Ps_High};
RETURNCODE_T ciWifiCtrl( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
BOOL cmdValid = FALSE;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
DBGMSG(ciWifiCtrl, "ciWifiCtrl: atHandle = %d.\n", atHandle);
switch (op)
{
case TEL_EXT_TEST_CMD: /* AT*WIFICTRL=? */
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*WIFICTRL:(0-3),(1-255),(4-255),(0-255),(0-255)" );
break;
}
case TEL_EXT_GET_CMD: /* AT*WIFICTRL? */
{
char rspBuf[50];
sprintf(rspBuf,"*WIFICTRL:%d\r\n",g_wifi_curr_option);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, rspBuf);
break;
}
case TEL_EXT_SET_CMD: /* AT*WIFICTRL=*/
{
INT32 option = 0;
int scanRoundNum = 0;
int scanMaxBssidNum = 0;
int sacnTimeout = 0;
int scanPri = 0;
UINT8 para_index = 0;
UINT8 queryFlag = 1;
if(getExtValue( parameter_values_p, 0, (int *)&option, TEL_AT_WIFLCTRL_OPTION_MIN, TEL_AT_WIFLCTRL_OPTION_MAX, TEL_AT_WIFLCTRL_OPTION_DEFAULT) == TRUE)
{
g_wifi_curr_option = option;
if(1 == option)
cmdValid = TRUE;
else if(0 == option)
cmdValid = TRUE;
else if(2 == option)
{
for(para_index = 1; para_index< num_parameters; para_index++)
{
if(parameter_values_p[para_index].is_default == FALSE)
{
queryFlag = 0;
break;
}
}
if(1 == queryFlag)
{
char rspBuf[50];
sprintf(rspBuf,"*WIFICTRL:%d,%d,%d,%d\r\n",gWifiScanCfg.ScanRoundNum,gWifiScanCfg.ScanMaxBssidNum,gWifiScanCfg.ScanTimeout,gWifiScanCfg.ScanPriority);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, rspBuf);
goto exit;
}
else
{
if(getExtValue( parameter_values_p, 1, (int *)&scanRoundNum, 1, 255, 3) == TRUE)
{
if(getExtValue( parameter_values_p, 2, (int *)&scanMaxBssidNum, 4, 255, 5) == TRUE)
{
if(getExtValue( parameter_values_p, 3, (int *)&sacnTimeout, 0, 255, 25) == TRUE)
{
if(getExtValue( parameter_values_p, 4, (int *)&scanPri, 0, 255, 0) == TRUE)
{
gWifiScanCfg.ScanRoundNum= (UINT8)scanRoundNum;
gWifiScanCfg.ScanMaxBssidNum= (UINT8)scanMaxBssidNum;
gWifiScanCfg.ScanTimeout= (UINT8)sacnTimeout;
gWifiScanCfg.ScanPriority= (ScanPriority_te)scanPri;
cmdValid = TRUE;
}
}
}
}
}
}
else if (3 == option)
cmdValid = TRUE;
else if (4 == option)
{
if(getExtValue( parameter_values_p, 1, (int *)&scanRoundNum, 1, 255, 3) == TRUE)
{
if(getExtValue( parameter_values_p, 2, (int *)&scanMaxBssidNum, 4, 255, 5) == TRUE)
{
if(getExtValue( parameter_values_p, 3, (int *)&sacnTimeout, 0, 255, 25) == TRUE)
{
gWifiScanCfg.ScanRoundNum= (UINT8)scanRoundNum;
gWifiScanCfg.ScanMaxBssidNum= (UINT8)scanMaxBssidNum;
gWifiScanCfg.ScanTimeout= (UINT8)sacnTimeout;
gWifiScanCfg.ScanPriority = (ScanPriority_te)0;
cmdValid = TRUE;
}
}
}
}
if(cmdValid)
{
ret = Dev_WifiScan(atHandle, option, scanRoundNum, scanMaxBssidNum, sacnTimeout, scanPri);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
exit:
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
/************************************************************************************
* F@: ciOverheat - GLOBAL API for AT*OVERHEAT -command
*
*/
RETURNCODE_T ciOverheat( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
//DBGMSG(ciOverheat, "ciAntennaTuner: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*OVERHEAT= */
{
int Val = 0;
if ( getExtValue( parameter_values_p, 0, &Val, TEL_AT_OVERHEAT_0_VAL_MIN, TEL_AT_OVERHEAT_0_VAL_MAX, TEL_AT_OVERHEAT_0_VAL_DEFAULT ) == TRUE )
{
ret = DEV_SetOverHeat(atHandle, (UINT8)Val);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
}
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciVoltageFreq - GLOBAL API for AT*VOLTAGEFREQ -command
*
*/
RETURNCODE_T ciVoltageFreq( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*VOLTAGEFREQ= */
{
int Val = 0;
if ( getExtValue( parameter_values_p, 0, &Val, TEL_AT_VOLTAGEFREQ_0_VAL_MIN, TEL_AT_VOLTAGEFREQ_0_VAL_MAX, TEL_AT_VOLTAGEFREQ_0_VAL_DEFAULT ) == TRUE )
{
ret = DEV_SetVoltageFreq(atHandle, (UINT8)Val);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
}
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#ifdef NR_POSITION_SUPPORT
/************************************************************************************
* F@: ciPositionFunc - GLOBAL API for GCF AT*POSFUN -command
*
*/
RETURNCODE_T ciPositionFunc( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*POSFUN = */
{
int cmd=0;
int id = 0;
int nw_mode = 0;
int segment_total_num = 0;
int segment_sequence_num = 0;
INT16 len = 0;
CHAR data[TEL_AT_POSFUN_4_DATA_MAX_LEN + ATCI_NULL_TERMINATOR_LENGTH];
BOOL cmdValid = FALSE;
if( getExtValue( parameter_values_p, 0, &cmd, TEL_AT_POSFUN_0_CMD_VAL_MIN,TEL_AT_POSFUN_0_CMD_VAL_MAX, TEL_AT_POSFUN_0_CMD_VAL_DEFAULT ) == TRUE )
{
if( getExtValue( parameter_values_p, 1, &nw_mode, TEL_AT_POSFUN_1_NW_MODE_VAL_MIN,TEL_AT_POSFUN_1_NW_MODE_VAL_MAX, TEL_AT_POSFUN_1_NW_MODE_VAL_DEFAULT ) == TRUE )
{
if( getExtValue( parameter_values_p, 2, &id, TEL_AT_POSFUN_2_ID_VAL_MIN,TEL_AT_POSFUN_2_ID_VAL_MAX, TEL_AT_POSFUN_2_ID_VAL_DEFAULT ) == TRUE )
{
if( getExtValue( parameter_values_p, 3, &segment_total_num, TEL_AT_POSFUN_3_SEGMENT_NUM_VAL_MIN,TEL_AT_POSFUN_3_SEGMENT_NUM_VAL_MAX, TEL_AT_POSFUN_3_SEGMENT_NUM_VAL_DEFAULT) == TRUE )
{
if( getExtValue( parameter_values_p, 4, &segment_sequence_num, TEL_AT_POSFUN_3_SEGMENT_NUM_VAL_MIN,TEL_AT_POSFUN_3_SEGMENT_NUM_VAL_MAX, TEL_AT_POSFUN_3_SEGMENT_NUM_VAL_DEFAULT) == TRUE )
{
ERRMSG(ciPositionFunc1,"%s: nw_mode %d, id %d, segment_total_num %d, segment_sequence_num %d", __FUNCTION__, nw_mode, id, segment_total_num, segment_sequence_num);
if( getExtString(parameter_values_p, 5, data, TEL_AT_POSFUN_4_DATA_MAX_LEN, &len, TEL_AT_POSFUN_4_DATA_DEFAULT) == TRUE)
{
cmdValid = TRUE;
}
}
}
}
}
}
if (cmdValid == TRUE)
{
if(cmd == 0) //get command
{
switch(id)
{
case CI_DEV_POSITION_ECID_MEAS:
ret = Dev_PosGet_ECID_MEAS(atHandle, (UINT8)nw_mode, data);
break;
case CI_DEV_POSITION_MULTI_RTT_MEAS:
ret = Dev_PosGet_MULTI_RTT_MEAS(atHandle, (UINT8)nw_mode, (UINT8)segment_total_num, (UINT8)segment_sequence_num, data);
break;
case CI_DEV_POSITION_DLAOD_MEAS:
ret = Dev_PosGet_DLAOD_MEAS(atHandle, (UINT8)nw_mode, (UINT8)segment_total_num, (UINT8)segment_sequence_num, data);
break;
case CI_DEV_POSITION_DLTDOA_MEAS:
ret = Dev_PosGet_DLTDOA_MEAS(atHandle, (UINT8)nw_mode, (UINT8)segment_total_num, (UINT8)segment_sequence_num, data);
break;
case CI_DEV_POSITION_POSSIB_MAPPING:
ret = Dev_PosGet_POSSIB_MAPPING(atHandle, (UINT8)nw_mode, (UINT8)segment_total_num, (UINT8)segment_sequence_num, data);
break;
case CI_DEV_POSITION_POSSIB_INFO_ACQUIRE:
ret = Dev_PosGet_POSSIB_INFO_ACQUIRE(atHandle, (UINT8)nw_mode, (UINT8)segment_total_num, (UINT8)segment_sequence_num, data);
break;
case CI_DEV_POSITION_POSSIB_INFO_VALIDITY:
ret = Dev_PosGet_POSSIB_INFO_VALIDITY(atHandle, (UINT8)nw_mode, (UINT8)segment_total_num, (UINT8)segment_sequence_num, data);
break;
case CI_DEV_POSITION_POSSIB_ENC_KEY:
ret = Dev_PosGet_POSSIB_ENC_KEY(atHandle, (UINT8)nw_mode, (UINT8)segment_total_num, (UINT8)segment_sequence_num, data);
break;
default:
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
else // stop command
{
switch(id)
{
case CI_DEV_POSITION_MULTI_RTT_MEAS:
case CI_DEV_POSITION_DLAOD_MEAS:
case CI_DEV_POSITION_DLTDOA_MEAS:
case CI_DEV_POSITION_POSSIB_INFO_ACQUIRE:
ret = Dev_PosStop_Common_Req(atHandle, (UINT8)id, (UINT8)nw_mode, (UINT8)segment_total_num, (UINT8)segment_sequence_num, data);
break;
default:
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*POSFUN? */
case TEL_EXT_ACTION_CMD: /* AT*POSFUN */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
#endif
/************************************************************************************
* F@: ciSocTemp - GLOBAL API for AT*SELECTSIMSLOT command
*
*/
RETURNCODE_T ciSELECTSIMSLOT( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p);
UNUSEDPARAM(parameter_values_p);
UNUSEDPARAM(num_parameters);
UNUSEDPARAM(info_text_p);
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
/*
* Put parser index into the variable
*/
*xid_p = atHandle;
int simSlot=0;
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT*SELECTSIMSLOT? */
{
ret = DEV_GetSimSlot(atHandle);
break;
}
case TEL_EXT_SET_CMD: /* AT*SELECTSIMSLOT= */
{
if(getExtValue(parameter_values_p, 0, &simSlot, 0, 1, 0) == TRUE)
{
ret = DEV_SetSimSlot(atHandle, simSlot);
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#if defined(ATCMD_UNIFY_CI) || defined(ATCMD_1802S_CI)|| defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
#define BLACK_CELL_INFO_LENGTH 300
RETURNCODE_T ciBLACKCELL(const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
int cmd = 0;
int nwMode = 0;
INT16 cellInfoLen = 0;
char *cellInfoBuffer = NULL;
*xid_p = atHandle;
DBGMSG(ciCAG, "%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*BLACKCELL= */
{
if(getExtValue(parameter_values_p, 0, &cmd, 0, CI_DEV_CMD_NUM-1, 0) == TRUE)
{
if(getExtValue(parameter_values_p, 1, &nwMode, 0, CI_DEV_NUM_EM_NETWORKS-1, 0) == TRUE)
{
cellInfoBuffer = utlCalloc(1, BLACK_CELL_INFO_LENGTH);
if (cellInfoBuffer == NULL)
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_UNKNOWN, NULL);
return utlFAILED;
}
if(getExtString(parameter_values_p, 2, cellInfoBuffer, BLACK_CELL_INFO_LENGTH - 1, &cellInfoLen, NULL) == TRUE)
{
if((cellInfoLen == 0) || (strcasecmp(cellInfoBuffer, "") == 0) )
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
else
ret = Dev_SetBlackCell(atHandle, cmd, nwMode, cellInfoBuffer, cellInfoLen);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
utlFree(cellInfoBuffer);
cellInfoBuffer = NULL;
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
case TEL_EXT_GET_CMD: /* AT*BLACKCELL? */
{
ret = Dev_GetBlackCell(atHandle);
break;
}
default:
{
ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciCSCO - GLOBAL API for GCF AT*CSCO command
*
*/
RETURNCODE_T ciCSCO( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
//UNUSEDPARAM(command_name_p)
//UNUSEDPARAM(num_parameters)
//UNUSEDPARAM(info_text_p)
//UNUSEDPARAM(xid_p)
//UNUSEDPARAM(arg_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
*xid_p = atHandle;
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT*CSCO=? */
{
/* No CI primitive for this: print hard-coded reply */
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CSCO=<offset_scell>,<offset_scell_qual>,<offset_ncell_lte>,<offset_ncell_lte_qual>,<offset_ncell_umts>,<offset_ncell_umts_qual>,<offset_ncell_gsm>" );
break;
}
case TEL_EXT_SET_CMD: /* AT*CSCO= */
{
UINT32 offset_scell = 0, offset_scell_qual = 0, offset_ncell_lte = 0, offset_ncell_lte_qual = 0, offset_ncell_umts = 0, offset_ncell_umts_qual = 0, offset_ncell_gsm = 0;
UINT32 paraStrLength = 0;
CHAR para1Str [10] = {0}, para2Str [10] = {0}, para3Str [10] = {0}, para4Str [10] = {0}, para5Str [10] = {0}, para6Str [10] = {0}, para7Str [10] = {0};
BOOL cmdValid = FALSE;
if ( getExtString(parameter_values_p, 0, para1Str, 5, &paraStrLength, NULL) == TRUE )
{
if(paraStrLength) offset_scell = atoi(para1Str);
if ( getExtString(parameter_values_p, 1, para2Str, 5, &paraStrLength, NULL) == TRUE )
{
if(paraStrLength) offset_scell_qual = atoi(para2Str);
if ( getExtString(parameter_values_p, 2, para3Str, 5, &paraStrLength, NULL) == TRUE )
{
if(paraStrLength) offset_ncell_lte = atoi(para3Str);
if ( getExtString(parameter_values_p, 3, para4Str, 5, &paraStrLength, NULL) == TRUE )
{
if(paraStrLength) offset_ncell_lte_qual = atoi(para4Str);
if ( getExtString(parameter_values_p, 4, para5Str, 5, &paraStrLength, NULL) == TRUE )
{
if(paraStrLength) offset_ncell_umts = atoi(para5Str);
if ( getExtString(parameter_values_p, 5, para6Str, 5, &paraStrLength, NULL) == TRUE )
{
if(paraStrLength) offset_ncell_umts_qual = atoi(para6Str);
if ( getExtString(parameter_values_p, 6, para7Str, 5, &paraStrLength, NULL) == TRUE )
{
if(paraStrLength) offset_ncell_gsm = atoi(para7Str);
if( (offset_scell > -100 && offset_scell < 100) && (offset_scell_qual > -20 && offset_scell_qual < 20) &&
(offset_ncell_lte > -100 && offset_ncell_lte < 100) && (offset_ncell_lte_qual > -20 && offset_ncell_lte_qual < 20) &&
(offset_ncell_umts > -100 && offset_ncell_umts < 100) && (offset_ncell_umts_qual > -20 && offset_ncell_umts_qual < 20) &&
(offset_ncell_gsm > -100 && offset_ncell_gsm < 100) )
{
cmdValid = TRUE;
ret = DEV_SetCellReselectConfigReq(atHandle, (INT8)offset_scell, (INT8)offset_scell_qual, (INT8)offset_ncell_lte, (INT8)offset_ncell_lte_qual, (INT8)offset_ncell_umts, (INT8)offset_ncell_umts_qual, (INT8)offset_ncell_gsm);
WARNMSG(ciCSCO1, "%s ==== offset_scell=%d,offset_scell_qual=%d,offset_ncell_lte=%d,offset_ncell_lte_qual=%d,offset_ncell_umts=%d,offset_ncell_umts_qual=%d,offset_ncell_gsm=%d",
__FUNCTION__,offset_scell,offset_scell_qual,offset_ncell_lte,offset_ncell_lte_qual,offset_ncell_umts,offset_ncell_umts_qual,offset_ncell_gsm);
}
}
}
}
}
}
}
}
if (cmdValid != TRUE)
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD:
ret = DEV_GetCellReselectConfigReq(atHandle);
break;
default:
{
ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
/************************************************************************************
* F@: cistarAVSIM - GLOBAL API for GCF AT*AVSIM -command
*
*/
typedef struct {
char VSIM_ICCID[10];
UINT8 vsimIccidLen;
char VSIM_IMSI[8];
UINT8 vsimImsiLen;
char VSIM_Para1[16];
UINT8 vsimPara1Len;
char VSIM_Para2[16];
UINT8 vsimPara2Len;
} VSIM_Para;
static void VSIM_str2hex(int src_len, char *psrc, char *pdest, int dest_len)
{
int i = 0;
char highpart =0;
char lowpart = 0;
char result = 0;
//ERRMSG(VSIM_str2hex0, "%s: src_len %d, dest_len %d", __func__,src_len, dest_len);
if((psrc == NULL) || (pdest == NULL))
return;
if(src_len > dest_len<<1)
return;
for (i = 0; i < src_len/2; i++) {
highpart = hexToNum(*psrc++);
//ERRMSG(VSIM_str2hex1, "%s: result[%d]: highpart %X\n", __FUNCTION__, i, highpart);
lowpart = hexToNum(*psrc++);
// ERRMSG(VSIM_str2hex2, "%s: result[%d]: lowpart %X\n", __FUNCTION__, i, lowpart);
result = (highpart<<4) | lowpart;
*pdest++ = result;
//ERRMSG(VSIM_str2hex3, "%s: result[%d]: %X, highpart %d, lowpart %d\n", __FUNCTION__, i, result, highpart, lowpart);
}
if (src_len%2 == 1)
{
highpart = hexToNum(*psrc++);
result = (highpart<<4) | 0xF;
*pdest++ = result;
}
}
static char iccidStr[21] = {0};
static char imsiStr[16] = {0};
static char para1Str[33] = {0};
static char para2Str[33] = {0};
RETURNCODE_T cistarAVSIM( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
UINT16 iccidStrLen = 0, imsiStrLen = 0, para1StrLen = 0, para2StrLen = 0;
VSIM_Para *vsimPara = NULL;
*xid_p = atHandle;
//INFOMSG(cistarAVSIM0, "cistarAVSIM: atHandle = %d.\n", atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_TEST_CMD: /* AT*AVSIM=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,(char *)"*AVSIM: <iccid>,<imsi>,<para1>,<para2>\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT*AVSIM= */
{
if(getExtString(parameter_values_p, 0, iccidStr, 21, &iccidStrLen, 0) == TRUE)
{
if(getExtString(parameter_values_p, 1, imsiStr, 16, &imsiStrLen, 0) == TRUE)
{
if(getExtString(parameter_values_p, 2, para1Str, 33, &para1StrLen, 0) == TRUE)
{
if(getExtString(parameter_values_p, 3, para2Str, 33, &para2StrLen, 0) == TRUE)
{
ERRMSG(cistarAVSIM0, "%s: iccidStr[%s], imsiStr[%s], para1Str[%s], para2Str[%s]",__FUNCTION__, iccidStr, imsiStr, para1Str, para2Str);
ERRMSG(cistarAVSIM1, "%s: iccidStrLen[%d], imsiStrLen[%d], para1StrLen[%d], para2StrLen[%d]", __FUNCTION__, iccidStrLen, imsiStrLen, para1StrLen, para2StrLen);
vsimPara = (VSIM_Para *)malloc(sizeof(VSIM_Para));
if (vsimPara)
{
vsimPara->vsimIccidLen = iccidStrLen%2==0?(iccidStrLen/2):(iccidStrLen/2+1);
vsimPara->vsimImsiLen = imsiStrLen%2==0?(imsiStrLen/2):(imsiStrLen/2+1);
vsimPara->vsimPara1Len = para1StrLen/2;
vsimPara->vsimPara2Len = para2StrLen/2;
VSIM_str2hex(iccidStrLen, iccidStr, vsimPara->VSIM_ICCID, vsimPara->vsimIccidLen);
VSIM_str2hex(imsiStrLen, imsiStr, vsimPara->VSIM_IMSI, vsimPara->vsimImsiLen);
VSIM_str2hex(para1StrLen, para1Str, vsimPara->VSIM_Para1, vsimPara->vsimPara1Len);
VSIM_str2hex(para2StrLen, para2Str, vsimPara->VSIM_Para2, vsimPara->vsimPara2Len);
ret = DEV_SetAVSIM(atHandle, (void *)vsimPara, sizeof(VSIM_Para));
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, 0, "malloc fail");
}
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT*AVSIM? */
{
char resp_buf[128] = {0};
memset(resp_buf, '\0', 128);
snprintf(resp_buf, sizeof(resp_buf)-1, "*AVSIM:%s,%s,%s,%s", iccidStr, imsiStr, para1Str, para2Str);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, resp_buf);
break;
}
case TEL_EXT_ACTION_CMD: /* AT*AVSIM */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
if (vsimPara)
{
free(vsimPara);
vsimPara = NULL;
}
return(rc);
}
char manufactureName[10]="ASR";
char HWVersionS[20] = "EVB_V2R2";
/************************************************************************************
* F@: ciREADVER - GLOBAL API for GCF AT*READVER command
*
*/
RETURNCODE_T ciREADVER( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
/*
* Put parser index into the variable
*/
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
char buf[200];
*xid_p = atHandle;
FILE *fp = fopen("/etc/mversion","r");
if(NULL == fp){
WARNMSG(ciREADVER,"open file failed!");
return false;
}
memset(buf, 0, sizeof(buf));
fgets(buf,200,fp);
buf[199] = '\0';
fclose(fp);
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_ACTION_CMD: /* AT*READVER */
{
char tmpBuf[512];
#if !defined(ATCMD_1901_CI) && !defined(ATCMD_1903_CI)
snprintf(tmpBuf, sizeof(tmpBuf) - 1,"*READVER: \r\nSW_Version: %s\r\n\r\nBaseband_Version: %s\r\n%s\r\n\r\nHW_Version: %s by %s\r\n",
buf,internalRevisionId, buildTimeStr,
HWVersionS,manufactureName);
#else
//KSTR_1.082.010X_A01901_::KESTREL_NLWG_M16_A0_GRF_MSA_1.082.010::
char openwrt_ver[16] = { 0 };
char project_ver[32] = { 0 };
char other_ver[64] = { 0 };
if (strcmp(internalRevisionId, "unknown") != 0)
{
sscanf(internalRevisionId, "%[^_]_%[^_]_%s", openwrt_ver, project_ver, other_ver);
project_ver[5] = 0;
}
else
strcpy(project_ver, "unknown");
#ifndef ATCMD_1903_CI
#ifndef CI_RELEASE_FLAG
snprintf(tmpBuf, sizeof(tmpBuf) - 1,"*READVER: \r\nSW_Version: KSTR_%s\r\nBaseband_Version: KSTR_%s\r\nHW_Version: EVB_2.2 by %s\r\n",
project_ver,project_ver,manufactureName);
#else
snprintf(tmpBuf, sizeof(tmpBuf) - 1,"*READVER: \r\nSW_Version: %s\r\n\r\nBaseband_Version: %s\r\n%s\r\n\r\nHW_Version: %s by %s\r\n",
buf,internalRevisionId, buildTimeStr,
HWVersionS,manufactureName);
#endif
#else
snprintf(tmpBuf, sizeof(tmpBuf) - 1,"*READVER: \r\nSW_Version: LPW_%s\r\nBaseband_Version: LPW_%s\r\nHW_Version: EVB_V1R0 by %s\r\n",
project_ver,project_ver,manufactureName);
#endif
#endif
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, tmpBuf);
break;
}
default:
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
break;
}
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciSENDIND - GLOBAL API for AT*IND command
*
*/
RETURNCODE_T ciSENDIND( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
/*
* Put parser index into the variable
*/
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
TelAtParserID sAtpIndex = *(TelAtParserID *)arg_p;
char *indBuf = NULL;
INT16 indLen = 0;
UINT32 IndHandler = IND_REQ_HANDLE;
UINT8 sendIndFlag = 1;
*xid_p = atHandle;
if (!GET_SIM1_FLAG(atHandle)) {
IndHandler = IND_REQ_HANDLE;
} else {
IndHandler = IND_REQ_HANDLE_1;
}
indBuf = (char*)calloc(1, 1024);
if(indBuf == NULL)
return RESULT_CODE_NULL;
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_SET_CMD: /* AT*IND= */
{
if (getExtString(parameter_values_p, 0, indBuf, 1024, &indLen, NULL) == TRUE)
{
ATRESP(IndHandler, 0, 0, indBuf);
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
break;
}
free(indBuf);
indBuf = NULL;
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciEEH - GLOBAL API for AT*EEH command
*
*/
extern configtype zconfigtype[];
RETURNCODE_T ciEEH(
const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
INT16 StrLen = 0;
*xid_p = atHandle;
int action = 0;
FILE *configFile = NULL;
CHAR returnStr[20] = {0};
//DBGMSG(ciEEH, "%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*EEH= */
{
if(getExtValue(parameter_values_p, 0, &action, 0, 1, 0) == TRUE)
{
DBGMSG(ciEEH0, "%s: action:%d", __FUNCTION__, action);
if(action == 1)
{
ERRMSG(ciEEH1, "%s: restart EEH", __FUNCTION__);
//system("killall eeh"); //kill eeh
//system("/bin/eeh -M yes &"); //restart eeh
executeShellCMD("killall eeh", returnStr);
executeShellCMD("/bin/eeh -M yes &", returnStr);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/************************************************************************************
* F@: ciDevTest - GLOBAL API for AT*DEVTEST command
*
*/
RETURNCODE_T ciDevTest(
const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
int type = 0, cmd = 0;
CHAR returnStr[60] = {0};
ASR_flag tag;
DBGMSG(ciDevTest, "%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT*DEVTEST= */
{
if(getExtValue(parameter_values_p, 0, &type, 0, 1, 0) == TRUE)
{
if(type == 1) // DDR test
{
if(getExtValue(parameter_values_p, 1, &cmd, 0, 1, 0) == TRUE)
{
if(cmd == 0) // start test
{
rc = get_asr_flag(&tag);
if(rc < 0)
{
WARNMSG(ciDevTest1, "read asr flag error\n");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_UNKNOWN, NULL);
}
else
{
tag.ddrt_state.bits.test_proc = 1; // start
tag.ddrt_state.bits.last_res = 1; //fail
rc = write_asr_flag(&tag);
if (rc < 0)
{
WARNMSG(ciDevTest2, "write asr flag error\n");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_UNKNOWN, NULL);
}
else
{
//executeShellCMD("reboot", returnStr);
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
}
}
else if(cmd == 1) // query result
{
rc = get_asr_flag(&tag);
if(rc < 0)
{
WARNMSG(ciDevTest3, "read asr flag error\n");
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_UNKNOWN, NULL);
}
else
{
UINT8 totalNum = 0;
UINT8 failNum = 0;
UINT8 result = 0;
totalNum = tag.ddrt_state.bits.total_times;
failNum = tag.ddrt_state.bits.fail_times;
result = !((tag.ddrt_state.bits.test_proc == 0) && (tag.ddrt_state.bits.last_res == 0) && (totalNum > failNum));
WARNMSG(ciDevTest4, "test_proc %d\n", tag.ddrt_state.bits.test_proc);
WARNMSG(ciDevTest5, "last_res %d\n", tag.ddrt_state.bits.last_res);
WARNMSG(ciDevTest6, "total_times %d\n", tag.ddrt_state.bits.total_times);
WARNMSG(ciDevTest7, "fail_times %d\n", tag.ddrt_state.bits.fail_times);
sprintf(returnStr, "*devtest: result %d, pass %d, fail %d", result, totalNum - failNum, failNum);
ret = ATRESP( atHandle, NULL, 0, returnStr);
if(!result)
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, "DDR PASS");
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, "DDR FAIL");
}
}
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
else
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
break;
}
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#if defined(ATCMD_UNIFY_CI) || defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
/************************************************************************************
* F@: AtRegRW - GLOBAL API for AT*REGRW command
*
************************************************************************************/
RETURNCODE_T AtRegRW( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
if(devVersion > 0x0001)
{
CHAR aString[2];
INT16 aStringLen;
CHAR RegAddr[12] = {'\0'};
INT16 RegAddrLen;
CHAR RegData[12] = {'\0'};
INT16 RegDataLen;
char *str;
UINT32 UIN32_RegAddr =0;
UINT32 UIN32_RegData =0;
*xid_p = atHandle;
switch( op )
{
case TEL_EXT_SET_CMD:
{
if (getExtString(parameter_values_p, 0, aString, 1, &aStringLen, NULL) == TRUE )
{
if ( !strcmp(aString,"r") || !strcmp(aString,"R"))
{
// This is write request
// get write parameters
if (getExtString( parameter_values_p, 1, RegAddr, 10,&RegAddrLen, 0) == TRUE )
{
CiDevPrimRwRegisterReq *pReqParms;
pReqParms = utlCalloc(1, sizeof(CiDevPrimRwRegisterReq));
if (pReqParms == NULL)
return CIRC_FAIL;
UIN32_RegAddr = strtoul(RegAddr,&str,16);
memset(pReqParms, 0, sizeof(CiDevPrimRwRegisterReq));
pReqParms->op = REG_READ;
pReqParms->addr = UIN32_RegAddr;
ret = ciRequest( gAtciSvgHandle[CI_SG_ID_DEV], CI_DEV_PRIM_RW_REGISTER_REQ,
MAKE_CI_REQ_HANDLE(atHandle, CI_DEV_PRIM_RW_REGISTER_REQ), (void *)pReqParms );
}
else
{
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
}
}
else if ( !strcmp(aString,"w")|| !strcmp(aString,"W"))
{
// This is a read request with version and date
if (getExtString( parameter_values_p, 1, RegAddr, 10, &RegAddrLen, 0) == TRUE )
{
if (getExtString( parameter_values_p, 2, RegData, 10, &RegDataLen, 0) == TRUE )
{
CiDevPrimRwRegisterReq *pReqParms;
pReqParms = utlCalloc(1, sizeof(CiDevPrimRwRegisterReq));
if (pReqParms == NULL)
return CIRC_FAIL;
UIN32_RegAddr = strtoul(RegAddr,&str,16);
UIN32_RegData = strtoul(RegData,&str,16);
memset(pReqParms, 0, sizeof(CiDevPrimRwRegisterReq));
pReqParms->op = REG_WRITE;
pReqParms->addr = UIN32_RegAddr;
pReqParms->value = UIN32_RegData;
ret = ciRequest( gAtciSvgHandle[CI_SG_ID_DEV], CI_DEV_PRIM_RW_REGISTER_REQ,
MAKE_CI_REQ_HANDLE(atHandle, CI_DEV_PRIM_RW_REGISTER_REQ), (void *)pReqParms );
}
else
{
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
}
}
else
{
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
}
}
else
{
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
}
}
else
{
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
}
break;
}
case TEL_EXT_GET_CMD:
{
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,0);
break;
}
default:
{
//ret = OPER_NOT_SUPPORTED;
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
break;
}
}
}
else
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
#ifdef CUSTQ
#if defined(ATCMD_1903_CI) || defined(ATCMD_1901_CI)
#if !defined(CI_RELEASE_FLAG)
/************************************************************************************
* F@: ciQnwPrefCfg - GLOBAL API for AT+QNWPREFCFG -command
*
*/
RETURNCODE_T ciQnwPrefCfg( const utlAtParameterOp_T op,
const char *command_name_p,
const utlAtParameterValue_P2c parameter_values_p,
const size_t num_parameters,
const char *info_text_p,
unsigned int *xid_p,
void *arg_p)
{
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
RETURNCODE_T rc = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
DBGMSG(ciQnwPrefCfg1,"%s: enter", __FUNCTION__);
/*
** Check the format of the request.
*/
switch (op)
{
case TEL_EXT_SET_CMD: /* AT+QNWPREFCFG= */
{
int mode = 0;
CHAR setting[20] = {'\0'};
INT16 settingLen = 0;
BOOL getFlag = FALSE;
BOOL cmdValid = FALSE;
if (getExtString( parameter_values_p, 0, setting, 20, &settingLen, 0) == TRUE )
{
if((settingLen != 0) && (strcasecmp(setting,"ue_redcap_setting") == 0))
{
if ( getExtValue( parameter_values_p, 1, &mode, 0, 2, 0 ) == TRUE )
{
cmdValid = TRUE;
if(parameter_values_p[1].is_default == TRUE)
getFlag = TRUE;
}
}
}
if (cmdValid == TRUE)
{
CHAR data[40] = {0};
if(getFlag == FALSE) //set operation
{
snprintf(data, 40, "0#%d#0#0", mode);
ret = Dev_SetComFeature(atHandle, (UINT8)CI_DEV_CMD_SET, (UINT16)CI_DEV_FT_SET_UE_MODE, data, 0, NULL);
}
else //get operation
{
ret = Dev_GetComFeature(atHandle, (UINT16)CI_DEV_FT_SET_UE_MODE, 0, NULL);
}
}
else
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT+QNWPREFCFG? */
case TEL_EXT_ACTION_CMD: /* AT+QNWPREFCFG */
default:
{
ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#endif
#endif
#endif