Gitiles
Code Review Sign In
192.168.1.100 / T108 / 68079a34bd515b0cb19525e8f12e582c14c30307 / . / marvell / lte-telephony / apps / atcmd_server_ss / src / teldbg.c
blob: cf35bcb890b78fbc2f60c213d0e47033e96a1347 [file] [log] [blame]
/*--------------------------------------------------------------------------------------------------------------------
(C) Copyright 2006, 2007 Marvell DSPC Ltd. All Rights Reserved.
-------------------------------------------------------------------------------------------------------------------*/
#include "ci_api_types.h"
#include "ci_api.h"
#include "teldef.h"
#include "telconfig.h"
#include "telatci.h"
#include "telatparamdef.h"
#include "telutl.h"
#include <stdio.h>
#include <teldef.h>
#include <fcntl.h>
// Add by mbtk
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <pthread.h>
#include <sys/epoll.h>
// End by mbtk
#if defined (BIONIC)
#include <cutils/properties.h>
#endif
#if defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
#include "ursp_inner.h"
#endif
extern AtciCharacterSet chset_type[];
extern AtciCharacterSet chset_type_1[];
extern BOOL isGsmChset[];
extern BOOL isGsmChset_1[];
extern CiShHandle gAtciShellHandle;
extern CiShHandle gAtciShReqHandle;
extern CiServiceHandle gAtciSvgHandle[CI_SG_NUMIDS + 1];
extern int loglevel;
extern void ciClientStubDeinit(void);
UINT8 gCmtlrAllow[NUM_OF_TEL_ATP] = {0};
UINT8 gCmtlrHandleID[256] = {0};
UINT8 gCmtlrAllow_1[NUM_OF_TEL_ATP] = {0};
UINT8 gCmtlrHandleID_1[256] = {0};
#define MAX_DUMP_LENGTH 160
void dbg_dump_buffer(char* name, char* buf, int len)
{
int i;
char dbgBuf[TEL_AT_CMDSTR_MAX_LEN], tempBuf[10];;
sprintf(dbgBuf, "Dump \"%s\" Buffer [len=%d]: \n", name, len);
for (i = 0; i < len && i < MAX_DUMP_LENGTH; i++)
{
sprintf(tempBuf, "%02X", (UINT8)buf[i]);
strcat(dbgBuf, tempBuf);
if (((i + 1) % 32) == 0) strcat(dbgBuf, "\n");
}
strcat(dbgBuf, "\n");
eeh_log(0, LOG_NOTICE, "%s", dbgBuf);
}
void dbg_dump_string(char* name, char* buf, int len)
{
int i;
char dbgBuf[TEL_AT_CMDSTR_MAX_LEN], tempBuf[10];;
sprintf(dbgBuf, "Dump \"%s\" Buffer [len=%d]: \n", name, len);
for (i = 0; i < len && i < MAX_DUMP_LENGTH; i++)
{
sprintf(tempBuf, "%c", buf[i]);
strcat(dbgBuf, tempBuf);
if (((i + 1) % 32) == 0) strcat(dbgBuf, "\n");
}
strcat(dbgBuf, "\n");
eeh_log(0, LOG_VERBOSE, "%s", dbgBuf);
}
/******************************************************************************
* Debugging AT Command
******************************************************************************/
/*******************************************************************
* FUNCTION: vHDL
*
* DESCRIPTION: Get Handlle value for debugging
*
* PARAMETERS:
*
* RETURNS:
*
*******************************************************************/
utlReturnCode_T vHDL( 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)
_CiServiceGroupId ciSvcGrpId;
*xid_p = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
if ( op == utlAT_PARAMETER_OP_GET)
{
VDBGMSG(vHDL, "this is get operation.\n");
}
else if ( op == utlAT_PARAMETER_OP_SET)
{
VDBGMSG(vHDL1, "this is set operation.\n");
}
for ( ciSvcGrpId = CI_SG_ID_CC; ciSvcGrpId <= CI_SG_NUMIDS; ciSvcGrpId++ )
{
DBGMSG(vHDL2, "ShellHandle[%d]: %d \r\n", ciSvcGrpId, gAtciSvgHandle[ciSvcGrpId]);
}
ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
return utlSUCCESS;
}
/*******************************************************************
* FUNCTION: vECHO
*
* DESCRIPTION: echo back whatever type in the first arg
*
* PARAMETERS:
*
* RETURNS:
*
*******************************************************************/
utlReturnCode_T vECHO( 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(op)
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
int i;
char tmp[255];
*xid_p = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
sprintf(tmp, "%s", parameter_values_p[0].value.string_p);
/* convert '-' to ',' */
for (i = 0; i < (int)strlen(tmp); i++)
{
if (tmp[i] == '-')
tmp[i] = ',';
}
ATRESP( *xid_p, ATCI_RESULT_CODE_OK, 0, tmp);
return utlSUCCESS;
}
/* debugging function for linux */
/******************************************************************************
* Command not implemented (faking for Qtopia Integration
******************************************************************************/
utlReturnCode_T ciCSCS( 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 = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UNUSEDPARAM(op)
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
/*
* Put parser index into the variable
*/
CiRequestHandle atHandle;
TelAtParserID sAtpIndex=TEL_AT_CMD_ATP_0;
AtciCharacterSet *pchset_type;
BOOL *pIsGsmChset;
sAtpIndex = *(TelAtParserID *)arg_p;
atHandle = MAKE_AT_HANDLE( sAtpIndex );
*xid_p = atHandle;
if (!GET_SIM1_FLAG(atHandle)) {
pchset_type = &chset_type[sAtpIndex];
pIsGsmChset = &isGsmChset[sAtpIndex];
} else {
pchset_type = &chset_type_1[sAtpIndex];
pIsGsmChset = &isGsmChset_1[sAtpIndex];
}
/*
* process operation
*/
switch(op)
{
case TEL_EXT_SET_CMD: /* AT+CSCS= */
{
char chset[10];
INT16 len=0;
memset(chset, 0, sizeof(chset));
if( getExtString( parameter_values_p, 0, (CHAR *)chset, 9, &len, NULL ) == TRUE )
{
if(strcmp(chset, "IRA") == 0){
*pIsGsmChset = FALSE;
*pchset_type = ATCI_CHSET_IRA;
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
}
else if(strcmp(chset, "UCS2") == 0){
*pIsGsmChset = FALSE;
*pchset_type = ATCI_CHSET_UCS2;
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
}
else if(strcmp(chset, "HEX") == 0){
*pIsGsmChset = FALSE;
*pchset_type = ATCI_CHSET_HEX;
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
}
// GSM chset is not implemented, just make workaround
else if(strcmp(chset, "GSM") == 0){
*pIsGsmChset = TRUE;
*pchset_type = ATCI_CHSET_IRA;
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;
}
case TEL_EXT_TEST_CMD: /* AT+CSCS=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CSCS: (\"IRA\",\"UCS2\",\"HEX\",\"GSM\")\r\n");
break;
}
case TEL_EXT_GET_CMD: /* AT+CSCS? */
{
if(*pIsGsmChset)
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CSCS: \"GSM\"\r\n");
else if(*pchset_type == ATCI_CHSET_IRA)
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CSCS: \"IRA\"\r\n");
else if(*pchset_type == ATCI_CHSET_UCS2) //coverity[string_null:SUPPRESS]
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CSCS: \"UCS2\"\r\n");
else if(*pchset_type == ATCI_CHSET_HEX)
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CSCS: \"HEX\"\r\n");
else
ret = ATRESP( atHandle,ATCI_RESULT_CODE_ERROR,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);
}
/************************************************************************************
* F@: ciStarCSCS - GLOBAL API for GCF AT*CSCS command
*
* Select CSCS setting from proxy
*
*/
RETURNCODE_T ciStarCSCS( 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 = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
UNUSEDPARAM(op)
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
/*
* Put parser index into the variable
*/
CiRequestHandle atHandle=0;
TelAtParserID sAtpIndex=TEL_AT_CMD_ATP_0;
AtciCharacterSet *pchset_type;
BOOL *pIsGsmChset;
int proxyID=0;
CHAR AtRspBuf [30] = {0};
sAtpIndex = * (TelAtParserID *) arg_p;
atHandle = MAKE_AT_HANDLE( sAtpIndex );
*xid_p = atHandle;
/*
* process operation
*/
switch(op)
{
case TEL_EXT_SET_CMD: /* AT+CSCS= */
{
char chset[10] = {0};
INT16 len=0;
if ( getExtValue(parameter_values_p, 0, &proxyID, 0, 0x7FFFFFFF, 0) == TRUE )
{
UINT32 atHandle_prxy = GET_AT_HANDLE(proxyID);
TelAtParserID sAtpIndex_prxy = (TelAtParserID)(GET_ATP_INDEX(atHandle_prxy));
DBGMSG(ciStarCSCS0, "%s: proxyID %d, chset_type %d, isGsmChset %d\n", __FUNCTION__, proxyID, chset_type[sAtpIndex_prxy], isGsmChset[sAtpIndex_prxy]);
pchset_type = &chset_type[sAtpIndex_prxy];
pIsGsmChset = &isGsmChset[sAtpIndex_prxy];
if (parameter_values_p[1].is_default)
{
/*get*/
if(*pIsGsmChset)
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CSCS: \"GSM\"\r\n");
else if(*pchset_type == ATCI_CHSET_IRA)
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CSCS: \"IRA\"\r\n");
else if(*pchset_type == ATCI_CHSET_UCS2)//coverity[string_null:SUPPRESS]
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CSCS: \"UCS2\"\r\n");
else if(*pchset_type == ATCI_CHSET_HEX)
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CSCS: \"HEX\"\r\n");
else
ret = ATRESP( atHandle,ATCI_RESULT_CODE_ERROR,0,NULL);
break;
}
if( getExtString( parameter_values_p, 1, (CHAR *)chset, 9, &len, NULL ) == TRUE )
{
if(strcmp(chset, "IRA") == 0){
*pIsGsmChset = FALSE;
*pchset_type = ATCI_CHSET_IRA;
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
}
else if(strcmp(chset, "UCS2") == 0){
*pIsGsmChset = FALSE;
*pchset_type = ATCI_CHSET_UCS2;
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
}
else if(strcmp(chset, "HEX") == 0){
*pIsGsmChset = FALSE;
*pchset_type = ATCI_CHSET_HEX;
ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
}
// GSM chset is not implemented, just make workaround
else if(strcmp(chset, "GSM") == 0){
*pIsGsmChset = TRUE;
*pchset_type = ATCI_CHSET_IRA;
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);
}
else
ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
break;
}
case TEL_EXT_TEST_CMD: /* AT+CSCS=? */
{
//coverity[string_null:SUPPRESS]
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CSCS: proxyID[,(\"IRA\",\"UCS2\",\"HEX\",\"GSM\")]\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@: cciReg - GLOBAL API for GCF AT*CCIREG command
*
*/
RETURNCODE_T cciReg( 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)
/*
** Set the result code to INITIAL_RETURN_CODE. This allows
** the indications to display the correct return code after the
** AT Command is issued.
*/
RETURNCODE_T rc = INITIAL_RETURN_CODE;
BOOL cmdValid = FALSE;
int regState;
UINT8 sgId;
static CiShOperDeregisterDefaultSgReq gDefDeregBuf;
static CiShOperDeregisterSgReq gSvgDeregBuf;
UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
*xid_p = atHandle;
/*
* process operation
*/
switch ( op )
{
case TEL_EXT_TEST_CMD: /* AT*CCIREG=? */
{
/* No CI primitive for this: print hard-coded reply */
ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CCIREG: 0" );
cmdValid = TRUE;
break;
}
/*
case TEL_EXT_GET_CMD: // AT*CCIREG?
{
// return CCI REg status
cmdValid = TRUE;
break;
}
*/
case TEL_EXT_SET_CMD: /* AT*CCIREG= */
{
if ( getExtValue( parameter_values_p, 0, &regState, TEL_AT_CCIREG_0_N_VAL_MIN, TEL_AT_CCIREG_0_N_VAL_MAX, TEL_AT_CCIREG_0_N_VAL_DEFAULT ) == TRUE )
{
if (regState == 0)
{
WARNMSG(cciReg, "DeRegister the default service group\n");
/* DeRegister the default service group. */
gDefDeregBuf.defHandle = gAtciShellHandle;
rc = ciShRequest( gAtciShellHandle, /* Shell Handle */
CI_SH_OPER_DEREGISTERDEFSG, /* Operation */
&gDefDeregBuf, /* parameters */
gAtciShReqHandle++ ); /* Opaque handle */
//DBGMSG(cciReg2, "DeRegister the service groups\n");
// deregister CCI service groups
for (sgId = CI_SG_ID_CC; sgId < CI_SG_NUMIDS; sgId++)
{
gSvgDeregBuf.handle = gAtciSvgHandle[sgId];
rc = ciShRequest( gAtciShellHandle, /* Shell Handle */
CI_SH_OPER_DEREGISTERSG, /* Operation */
&gSvgDeregBuf, /* parameters */
gAtciShReqHandle++ ); /* Opaque handle */
}
//DBGMSG(cciReg3, "DeRegister the shell\n");
// deregister shell
rc = ciShDeregisterReq(gAtciShellHandle, gAtciShReqHandle++);
sleep(1000);
WARNMSG(cciReg4, "Deinit ci client\n");
ciClientStubDeinit();
}
else
{
//WARNMSG(cciReg5, "to be implemented!!!\n");
}
cmdValid = TRUE;
}
break;
}
default:
{
break;
}
}
if ( !cmdValid )
{
ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
}
else
rc = utlSUCCESS;
return(rc);
}
/*******************************************************************
* FUNCTION: vDump
*
* DESCRIPTION: Used to dump the loglevel
*
* PARAMETERS:
*
* RETURNS:
*
*******************************************************************/
utlReturnCode_T vDump( 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)
TelAtParserID sAtpIndex;
sAtpIndex = *(TelAtParserID *)arg_p;
*xid_p = MAKE_AT_HANDLE(sAtpIndex);
CiReturnCode ret = CIRC_FAIL;
RETURNCODE_T rc = INITIAL_RETURN_CODE;
int level;
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+VDUMP? */
{
char buf[50];
sprintf(buf, "+VDUMP: %d", get_log_level());
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, buf);
break;
}
case TEL_EXT_SET_CMD: /* AT+VDUMP= */
{
if ( getExtValue( parameter_values_p, 0, &level, TELEPHONY_MODULE_LOG_SILENT, TELEPHONY_MODULE_LOG_DEBUG, TELEPHONY_MODULE_LOG_NOTICE) == TRUE )
{
set_telephony_default_log_level(level);
set_log_level(level);
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
}
else
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
break;
}
default:
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
break;
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/*******************************************************************
* FUNCTION: vDump
*
* DESCRIPTION: Used to dump the loglevel
*
* PARAMETERS:
*
* RETURNS:
*
*******************************************************************/
utlReturnCode_T vLog( 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)
TelAtParserID sAtpIndex;
int log = 0, para = 0, para2 = 0;
char buf[100];
sAtpIndex = *(TelAtParserID *)arg_p;
*xid_p = MAKE_AT_HANDLE(sAtpIndex);
CiReturnCode ret = CIRC_FAIL;
RETURNCODE_T rc = INITIAL_RETURN_CODE;
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+log? */
{
sprintf(buf, "+log: %d, %d", log, para);
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, buf);
break;
}
case TEL_EXT_SET_CMD: /* AT+log=*/
{
if ( getExtValue( parameter_values_p, 0, &log, 0, 255, 0) == TRUE )
{
if ( getExtValue( parameter_values_p, 1, &para, 0, 255, 0) == TRUE )
{
switch (log)
{
case 1:
{
unsigned int seek = 0, data[2] = {0};
FILE *fd;
if ( getExtValue( parameter_values_p, 2, &para2, 0, 0x6000000, 0) != TRUE )
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, "Get ext valur error" );
break;
}
else
{
data[1] = para2;
}
switch(para)
{
case 0:
{
data[0] = 0x50686565; //eehP
seek = 52;
break;
}
case 1:
{
data[0] = 0x52535043; //cpsr
seek = 60;
break;
}
case 2:
{
data[0] = 0x4B574148; //hawk
seek = 68;
break;
}
case 3:
{
data[0] = 0x44534D49; //imsd
seek = 76;
break;
}
case 4:
{
data[0] = 0x45504950; //pipe
seek = 84;
break;
}
case 5:
{
data[0] = 0x54534146; //fast
seek = 92;
break;
}
case 6:
{
data[0] = 0x464D5041; //apmf
seek = 100;
break;
}
case 7:
{
data[0] = 0x00444950; //pid
seek = 108;
break;
}
case 8:
{
data[0] = 0x00444956; //vid
seek = 116;
break;
}
case 9:
{
data[0] = 0x444D424F; //obmd
seek = 124;
break;
}
default:
{
data[0] = 0x444D424F; //obmd
seek = 124;
break;
}
}
/* Preparing file */
fd = fopen("/tmp_log_file.bin", "wb");
if (!fd) {
ret = ATRESP( *xid_p,ATCI_RESULT_CODE_CME_ERROR,CMS_UNKNOWN_ERROR,"Open file error");
break;
}
ret = fwrite(&data, sizeof(data), 1, fd);
if (ret != 1) {
fclose(fd);
ret = ATRESP( *xid_p,ATCI_RESULT_CODE_CME_ERROR,CMS_UNKNOWN_ERROR,"write file error");
break;
}
fclose(fd);
/* Preparing to write to flash */
ret = snprintf(buf, 100, "dd if=%s of=%s bs=1 count=8 seek=%u > /dev/null 2>&1", "/tmp_log_file.bin", getAsrFlagPath(), seek);
if (ret >= 100) {
ret = ATRESP( *xid_p,ATCI_RESULT_CODE_CME_ERROR,CMS_UNKNOWN_ERROR,"snprintf length error");
break;
}
/* Writing to flash with DD */
ret = system(buf);
if (ret == -1) {
ret = ATRESP( *xid_p,ATCI_RESULT_CODE_CME_ERROR,CMS_UNKNOWN_ERROR,"DD command error");
break;
}
sync();
/* Removing temp file */
ret = remove("/tmp_log_file.bin");
if (ret) {
ret = ATRESP( *xid_p,ATCI_RESULT_CODE_CME_ERROR,CMS_UNKNOWN_ERROR,"Remove file error");
break;
}
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case 2:
{
cp_set_ddr_flag(0x00, 0x444D424F);
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case 4: // AP crash
{
switch(para)
{
case 0:
{
ASSERT(0);
break;
}
case 1:
{
ERRMSG(DBG, "%s: AP crash 1", __FUNCTION__);
*(volatile unsigned int *)0xFFFFFFFF = 0;
ERRMSG(DBG, "%s: AP crash 2", __FUNCTION__);
break;
}
default:
{
int fd = -1;
//echo B > /dev/ramdump_ctl
fd = open("/dev/ramdump_ctl", O_RDWR | O_SYNC);
if (fd >= 0) {
write(fd, "B", 1);
close(fd);
}
break;
}
}
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case 14: // CP Assert
{
int fd = -1;
//echo a > /dev/acipc
fd = open("/dev/acipc", O_RDWR | O_SYNC);
if (fd >= 0) {
write(fd, "a", 1);
close(fd);
}
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case 15:
{
#if defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
ursp_init();
#endif
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case 16: //
{
CHAR returnStr[40] = {0};
if ( getExtUValue( parameter_values_p, 2, &para2, 0, 0xFFFFFFFF, 0) != TRUE ) // len
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
break;
}
switch(para)
{
case 0: // don't rest diag buffer length
{
sprintf(buf, "echo %llu,0 > /proc/DiagDev_Debug/diagbuf_len", para2<<20);
executeShellCMD(buf, returnStr);
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case 1: //rest diag buffer length
{
sprintf(buf, "echo %llu,1 > /proc/DiagDev_Debug/diagbuf_len", para2<<20);
executeShellCMD(buf, returnStr);
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
break;
}
case 2: //read
{
executeShellCMD("cat /proc/DiagDev_Debug/diagbuf_len", returnStr);
ret = ATRESP(*xid_p,ATCI_RESULT_CODE_OK,0,returnStr);
break;
}
default:
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
break;
}
}
break;
}
default:
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
break;
}
}
}
else
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
}
}
else
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
}
break;
}
default:
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/* End Fake commands for Qtopia Integration*/
#if defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
utlReturnCode_T ciAPPSTART( 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 = INITIAL_RETURN_CODE;
CiReturnCode ret = CIRC_FAIL;
int mode = 0;
CHAR osId[MAX_LEN_OF_OS_ID] = {0};
INT16 osIdLen = 0;
CHAR appId[MAX_LEN_OF_OS_APP_ID + 1] = {0};
INT16 appIdLen = 0;
CHAR ipv4Addr[CI_PS_PDP_IP_V4_SIZE + 1] = {0};
INT16 ipv4AddrLen = 0;
CHAR ipv6Addr[CI_PS_PDP_IP_V6_SIZE + 1] = {0};
INT16 ipv6AddrLen = 0;
int protocolID = 0;
int singleRemotePort = 0;
CHAR portRange[TEL_AT_APPSTART_7_PORT_RANGE_STR_MAX_LEN + 1] = {0};
INT16 portRangeLen = 0;
CHAR DNN[TEL_AT_APPSTART_8_DNN_STR_MAX_LEN + 1] = {0};
INT16 DNNLen = 0;
int connectCap = 0;
CHAR FQDN[TEL_AT_APPSTART_10_FQDN_STR_MAX_LEN + 1] = {0};
INT16 FQDNLen = 0;
BOOL paraValid = FALSE;
AppInfo rcvAppInfo;
UNUSEDPARAM(op)
UNUSEDPARAM(command_name_p)
UNUSEDPARAM(parameter_values_p)
UNUSEDPARAM(num_parameters)
UNUSEDPARAM(info_text_p)
/*
* Put parser index into the variable
*/
CiRequestHandle atHandle;
TelAtParserID sAtpIndex;
sAtpIndex = *(TelAtParserID *)arg_p;
atHandle = MAKE_AT_HANDLE( sAtpIndex );
*xid_p = atHandle;
/*
* process operation
*/
switch(op)
{
case TEL_EXT_SET_CMD: /* AT*APPSTART= */
{
memset(&rcvAppInfo, 0, sizeof(rcvAppInfo));
if ( getExtValue( parameter_values_p, 0, &mode, TEL_AT_APPSTART_0_MODE_VAL_MIN, TEL_AT_APPSTART_0_MODE_VAL_MAX, TEL_AT_APPSTART_0_MODE_VAL_DEFAULT ) == TRUE )
{
if( getExtString( parameter_values_p, 1, (CHAR *)osId, MAX_LEN_OF_OS_ID, &osIdLen, NULL ) == TRUE )
{
if((parameter_values_p[1].is_default == TRUE) || !osIdLen)
rcvAppInfo.osIdPresent = FALSE;
else
{
rcvAppInfo.osIdPresent = TRUE;
memcpy(rcvAppInfo.osId, osId, osIdLen);
}
if( getExtString( parameter_values_p, 2, (CHAR *)appId, MAX_LEN_OF_OS_APP_ID, &appIdLen, NULL ) == TRUE )
{
if((parameter_values_p[2].is_default == TRUE) || !appIdLen)
rcvAppInfo.appIdPresent = FALSE;
else
{
rcvAppInfo.appIdPresent = TRUE;
memcpy(rcvAppInfo.appId, appId, appIdLen);
}
if ( getExtString( parameter_values_p, 3, ipv4Addr, TEL_AT_APPSTART_3_IPV4_ADDRESS_STR_MAX_LEN, &ipv4AddrLen, TEL_AT_APPSTART_3_IPV4_ADDRESS_STR_DEFAULT) == TRUE )
{
if((parameter_values_p[3].is_default == TRUE) || !ipv4AddrLen)
rcvAppInfo.ipv4AddrPresent = FALSE;
else
{
rcvAppInfo.ipv4AddrPresent = TRUE;
memcpy(rcvAppInfo.ipv4Addr, ipv4Addr, ipv4AddrLen);
}
if ( getExtString( parameter_values_p, 4, ipv6Addr, TEL_AT_APPSTART_4_IPV6_ADDRESS_STR_MAX_LEN, &ipv6AddrLen, TEL_AT_APPSTART_4_IPV6_ADDRESS_STR_DEFAULT) == TRUE )
{
if((parameter_values_p[4].is_default == TRUE) || !ipv6AddrLen)
rcvAppInfo.ipv6AddrPresent = FALSE;
else
{
rcvAppInfo.ipv6AddrPresent = TRUE;
memcpy(rcvAppInfo.ipv6Addr, ipv6Addr, ipv6AddrLen);
}
if ( getExtValue( parameter_values_p, 5, &protocolID, TEL_AT_APPSTART_5_PROTOCOLID_VAL_MIN, TEL_AT_APPSTART_5_PROTOCOLID_VAL_MAX, TEL_AT_APPSTART_5_PROTOCOLID_VAL_DEFAULT ) == TRUE )
{
if(parameter_values_p[5].is_default == TRUE)
rcvAppInfo.protocolIDPresent = FALSE;
else
{
rcvAppInfo.protocolIDPresent = TRUE;
rcvAppInfo.protocolID = protocolID;
}
if( getExtValue( parameter_values_p, 6, &singleRemotePort, TEL_AT_APPSTART_6_SINGLE_PORT_VAL_MIN, TEL_AT_APPSTART_6_SINGLE_PORT_VAL_MAX, TEL_AT_APPSTART_6_SINGLE_PORT_VAL_DEFAULT) == TRUE )
{
if(parameter_values_p[6].is_default == TRUE)
rcvAppInfo.singleRemotePortPresent = FALSE;
else
{
rcvAppInfo.singleRemotePortPresent = TRUE;
rcvAppInfo.singleRemotePort = singleRemotePort;
}
if( getExtString( parameter_values_p, 7, portRange, TEL_AT_APPSTART_7_PORT_RANGE_STR_MAX_LEN, &portRangeLen , (CHAR *)TEL_AT_APPSTART_7_PORT_RANGE_STR_DEFAULT) == TRUE )
{
if((parameter_values_p[7].is_default == TRUE) || !portRangeLen)
rcvAppInfo.portRangePresent = FALSE;
else
{
rcvAppInfo.portRangePresent = TRUE;
memcpy(rcvAppInfo.portRange, portRange, portRangeLen);
}
if ( getExtString(parameter_values_p, 8, DNN, TEL_AT_APPSTART_8_DNN_STR_MAX_LEN, &DNNLen, TEL_AT_APPSTART_8_DNN_STR_DEFAULT) == TRUE )
{
if((parameter_values_p[8].is_default == TRUE) || !DNNLen)
rcvAppInfo.DNNPresent = FALSE;
else
{
rcvAppInfo.DNNPresent = TRUE;
memcpy(rcvAppInfo.DNN, DNN, DNNLen);
}
if ( getExtValue( parameter_values_p, 9, &connectCap, TEL_AT_APPSTART_9_CON_CAP_VAL_MIN, TEL_AT_APPSTART_9_CON_CAP_VAL_MAX, TEL_AT_APPSTART_9_CON_CAP_VAL_DEFAULT ) == TRUE )
{
if(parameter_values_p[9].is_default == TRUE)
rcvAppInfo.connectCapPresent = FALSE;
else
{
rcvAppInfo.connectCapPresent = TRUE;
rcvAppInfo.connectCap = connectCap;
}
if ( getExtString(parameter_values_p, 10, FQDN, TEL_AT_APPSTART_10_FQDN_STR_MAX_LEN, &FQDNLen, TEL_AT_APPSTART_10_FQDN_STR_DEFAULT) == TRUE )
{
if((parameter_values_p[10].is_default == TRUE) || !FQDNLen)
rcvAppInfo.FQDNPresent = FALSE;
else
{
rcvAppInfo.FQDNPresent = TRUE;
memcpy(rcvAppInfo.FQDN, FQDN, FQDNLen);
}
paraValid = TRUE;
ursp_app_start(mode, &rcvAppInfo);
}
}
}
}
}
}
}
}
}
}
}
if(paraValid)
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_TEST_CMD: /* AT*APPSTART=? */
case TEL_EXT_GET_CMD: /* AT*APPSTART? */
{
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);
}
#endif
/*******************************************************************
* FUNCTION: APLOG
*
* DESCRIPTION: Used to control the ap log
*
* PARAMETERS:
*
* RETURNS:
*
*******************************************************************/
utlReturnCode_T apLog( 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)
TelAtParserID sAtpIndex;
int log = 0, err = 0;
unsigned char diagLogFlag = 0;
char respBuf[64];
sAtpIndex = *(TelAtParserID *)arg_p;
*xid_p = MAKE_AT_HANDLE(sAtpIndex);
CiReturnCode ret = CIRC_FAIL;
RETURNCODE_T rc = INITIAL_RETURN_CODE;
memset(respBuf, '\0', sizeof(respBuf));
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+APLOG? */
{
err = get_diag_log_flag(&diagLogFlag);
if (err == 0)
{
sprintf(respBuf, "+APLOG: %d", diagLogFlag);
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, respBuf);
}
else
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
}
break;
}
case TEL_EXT_SET_CMD: /* AT+APLOG= */
{
if ( getExtValue( parameter_values_p, 0, &log, 0, 255, 0) == TRUE )
{
err = set_diag_log_flag((unsigned char)log);
if (err != 0)
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
break;
}
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
}
else
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
}
break;
}
default:
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/*******************************************************************
* FUNCTION: diagMediaSwitch
*
* DESCRIPTION: Used to control the diag media
*
* PARAMETERS:
*
* RETURNS:
*
*******************************************************************/
utlReturnCode_T diagMediaSwitch( 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)
TelAtParserID sAtpIndex;
int save = 0, err = 0;
CHAR diag_media[8] = {0};
INT16 strLen = 0;
CHAR returnStr[32] = {0};
CHAR cmdStr[32] = {0};
sAtpIndex = *(TelAtParserID *)arg_p;
*xid_p = MAKE_AT_HANDLE(sAtpIndex);
CiReturnCode ret = CIRC_FAIL;
RETURNCODE_T rc = INITIAL_RETURN_CODE;
memset(diag_media, '\0', sizeof(diag_media));
switch ( op )
{
case TEL_EXT_SET_CMD: /* AT*DIAGSWITCH= */
{
if( getExtString( parameter_values_p, 0, (CHAR *)diag_media, 8, &strLen, NULL ) == TRUE )
{
if ( getExtValue( parameter_values_p, 1, &save, 0, 1, 0) == TRUE )
{
ERRMSG(diagMediaSwitch001, "%s: diag_media=%s, save=%u\n", __FUNCTION__, diag_media, save);
if (strLen > 0)
{
if (save > 0)
{
memset(returnStr, 0x00, sizeof(returnStr));
memset(cmdStr, 0x00, sizeof(cmdStr));
snprintf(cmdStr, sizeof(cmdStr), "/bin/diagcmd save %s", diag_media);
err = executeShellCMD(cmdStr, returnStr);
ERRMSG(diagMediaSwitch002, "%s: err=%d, returnStr=%s\n", __FUNCTION__, err, returnStr);
}
memset(returnStr, 0x00, sizeof(returnStr));
memset(cmdStr, 0x00, sizeof(cmdStr));
snprintf(cmdStr, sizeof(cmdStr), "/bin/diagcmd switch %s", diag_media);
err = executeShellCMD(cmdStr, returnStr);
ERRMSG(diagMediaSwitch003, "%s: err=%d, returnStr=%s\n", __FUNCTION__, err, returnStr);
}
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
}
}
else
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
}
break;
}
case TEL_EXT_GET_CMD: /* AT*DIAGSWITCH? */
default:
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
/*******************************************************************
* FUNCTION: ciRdup
*
* DESCRIPTION: Used to control the RDUP flag
*
* PARAMETERS:
*
* RETURNS:
*
*******************************************************************/
utlReturnCode_T ciRdup( 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)
TelAtParserID sAtpIndex;
int rdup = 0, err = 0;
CHAR returnStr[32] = {0};
sAtpIndex = *(TelAtParserID *)arg_p;
*xid_p = MAKE_AT_HANDLE(sAtpIndex);
CiReturnCode ret = CIRC_FAIL;
RETURNCODE_T rc = INITIAL_RETURN_CODE;
switch ( op )
{
case TEL_EXT_GET_CMD: /* AT+RDUP? */
{
break;
}
case TEL_EXT_SET_CMD: /* AT+RDUP= */
{
if ( getExtValue( parameter_values_p, 0, &rdup, 0, 1, 0) == TRUE )
{
// ERRMSG(ciRdup000, "%s: rdup=%d\n", __FUNCTION__, rdup);
if (rdup == 0)
{
memset(returnStr, 0x00, sizeof(returnStr));
err = executeShellCMD("echo 0 > /proc/sys/kernel/rdup", returnStr);
ERRMSG(ciRdup001, "%s: err=%d\n", __FUNCTION__, err);
}
else if (rdup == 1)
{
memset(returnStr, 0x00, sizeof(returnStr));
err = executeShellCMD("echo 1 > /proc/sys/kernel/rdup", returnStr);
ERRMSG(ciRdup002, "%s: err=%d\n", __FUNCTION__, err);
}
else
{
//nothing to be do
}
ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
}
else
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
}
break;
}
default:
{
ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
#ifdef GPS_SUPPORT
#include "gps.h"
#include "atcmdsvr_ubus.h"
const struct blobmsg_policy gps_user_cb_policy[] = {
[0] = {
.name = "event",
.type = BLOBMSG_TYPE_INT32,
},
};
const struct blobmsg_policy gps_state_resp_cb_policy[] = {
[0] = {
.name = "gps_state_resp",
.type = BLOBMSG_TYPE_STRING,
},
};
static void gps_usr_callback_hdl(struct ubus_request *req, int type, struct blob_attr *msg)
{
UNUSEDPARAM(type);
struct blob_attr *tb[1];
struct blob_attr *cur;
unsigned int event;
UINT32 atHandle = *(int *)req->priv;
int rc;
/*parsing blob to be accessed easily with tb array - parse "1" argument*/
rc = blobmsg_parse(gps_user_cb_policy, 1, tb, blob_data(msg), blob_len(msg));
if (rc < 0) {
ERRMSG(gps_usr_callback_hdl0, "gps_usr_callback_hdl: blobmsg_parse fail\n");
ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, CME_UNKNOWN, NULL);
return;
}
/*parse first parameter*/
cur = tb[0];
if (!cur) {
ERRMSG(gps_usr_callback_hdl1, "gps_usr_callback_hdl: missing parameter\n");
ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, CME_UNKNOWN, NULL);
return;
}
event = blobmsg_get_u32(cur);
ERRMSG(gps_usr_callback_hdl2, "%s: event=%d",__func__, event);
switch(event)
{
case ASR_GPS_INITIAL_SUCCESS:
case ASR_GPS_INITIALED:
ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: start up success.\r\n");
break;
case ASR_GPS_INITIAL_FAILED:
ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: start up fail.\r\n");
break;
case ASR_GPS_DOWNLOAD_SUCCESS:
ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: AGPS download success.\r\n");
break;
case ASR_GPS_DOWNLOAD_FAIL:
ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: AGPS download fail.\r\n");
break;
case ASR_GPS_SEND_DATA_SUCCESS:
ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: AGPS send success.\r\n");
break;
case ASR_GPS_SEND_DATA_FAIL:
ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: AGPS send fail.\r\n");
break;
case ASR_GPS_DEINIT_SUCCESS:
ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: AGPS poweroff success.\r\n");
break;
case ASR_GPS_DEINIT_FAIL:
ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: AGPS poweroff fail.\r\n");
break;
default:
break;
}
return;
}
static void gps_state_response_callback(struct ubus_request *req, int type, struct blob_attr *msg)
{
UNUSEDPARAM(type);
struct blob_attr *tb[1];
struct blob_attr *cur;
char *gps_state;
UINT32 atHandle = *(int *)req->priv;
int rc;
char outString[128] = {0};
/*parsing blob to be accessed easily with tb array - parse "1" argument*/
rc = blobmsg_parse(gps_state_resp_cb_policy, 1, tb, blob_data(msg), blob_len(msg));
if (rc < 0) {
ERRMSG(gps_state_response_callback0, "gps_state_response_callback: blobmsg_parse fail\n");
ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, CME_UNKNOWN, NULL);
return;
}
/*parse first parameter*/
cur = tb[0];
if (!cur) {
ERRMSG(gps_state_response_callback1, "gps_state_response_callback: missing parameter\n");
ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, CME_UNKNOWN, NULL);
return;
}
gps_state = blobmsg_get_string(cur);
ERRMSG(gps_state_response_callback12, "%s: gps_state=%s",__func__, gps_state);
memset(outString, '\0', sizeof(outString));
snprintf(outString, sizeof(outString), "+GPSST: %s\r\n", gps_state);
ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, outString);
return;
}
RETURNCODE_T ciGPSInit(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;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_GET_CMD: /* AT+GPSINIT? */
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
break;
}
case TEL_EXT_TEST_CMD: /* AT+GPSINIT=? */
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSINIT: (1,2)\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT+GPSINIT= */
{
INT32 gps_init_val;
/* Extract the arguments starting with the functionality. */
if (getExtValue(parameter_values_p, 0, (int *)&gps_init_val, 0, 1, 1) == TRUE)
{
struct blob_buf outBlob;
memset(&outBlob, 0, sizeof(outBlob));
blob_buf_init(&outBlob, 0);
blobmsg_add_u32(&outBlob, "gnss_init_param", (unsigned int)gps_init_val);
if (invoke_reply_data_cb_ril(origParserId, "gps", "gnss_init", outBlob.head, (ubus_data_handler_t *)gps_usr_callback_hdl, &atHandle, 8000) == UBUS_STATUS_OK)
{
ret = CIRC_SUCCESS;
}
else
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,NULL);
}
blob_buf_free(&outBlob);
}
else
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_ACTION_CMD: /* AT+GPSINIT */
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 ciGPSSleep(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;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_GET_CMD: /* AT+GPSSLEEP? */
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
break;
}
case TEL_EXT_TEST_CMD: /* AT+GPSSLEEP=? */
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSSLEEP: (0,1)\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT+GPSSLEEP= */
{
INT32 gps_sleep_val;
/* Extract the arguments starting with the functionality. */
if (getExtValue(parameter_values_p, 0, (int *)&gps_sleep_val, 0, 1, 0) == TRUE)
{
struct blob_buf outBlob;
memset(&outBlob, 0, sizeof(outBlob));
blob_buf_init(&outBlob, 0);
blobmsg_add_u32(&outBlob, "gnss_sleep_param", (unsigned int)gps_sleep_val);
if (invoke_noreply_ril(origParserId, "gps", "gnss_sleep", outBlob.head) == UBUS_STATUS_OK)
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_OK,0,NULL);
}
else
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,NULL);
}
blob_buf_free(&outBlob);
}
else
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_ACTION_CMD: /* AT+GPSSLEEP */
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 ciGPSPF(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;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_ACTION_CMD: /* AT+GPSPF */
{
if (invoke_reply_data_cb_ril(origParserId, "gps", "gnss_deinit", NULL, (ubus_data_handler_t *)gps_usr_callback_hdl, &atHandle, 5000) == UBUS_STATUS_OK)
{
ret = CIRC_SUCCESS;
}
else
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,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);
}
RETURNCODE_T ciAGnssGet(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;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_GET_CMD: /* AT+AGNSSGET? */
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
break;
}
case TEL_EXT_TEST_CMD: /* AT+AGNSSGET=? */
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+AGNSSGET: <supl_server_addr>\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT+AGNSSGET= */
{
#define SUPL_SERVER_ADDR_LEN 256
char supl_server[SUPL_SERVER_ADDR_LEN];
char lat[16], lon[16], acc[16];
INT16 supl_server_len = 0, lat_len = 0, lon_len = 0, acc_len = 0;
memset(supl_server, 0, SUPL_SERVER_ADDR_LEN);
memset(lat, 0x00, 16);
memset(lon, 0x00, 16);
memset(acc, 0x00, 16);
int alm_flag;
/* Extract the arguments starting with the functionality. */
if (getExtString(parameter_values_p, 0, supl_server, SUPL_SERVER_ADDR_LEN, &supl_server_len, NULL) == TRUE)
{
if (getExtValue(parameter_values_p, 1, &alm_flag, 0, 3, 0) == TRUE)
{
if (getExtString(parameter_values_p, 2, lat, 16, &lat_len, NULL) == TRUE)
{
if (getExtString(parameter_values_p, 3, lon, 16, &lon_len, NULL) == TRUE)
{
if (getExtString(parameter_values_p, 4, acc, 16, &acc_len, NULL) == TRUE)
{
struct blob_buf outBlob;
memset(&outBlob, 0, sizeof(outBlob));
blob_buf_init(&outBlob, 0);
blobmsg_add_string(&outBlob, "server_name", supl_server);
blobmsg_add_u32(&outBlob, "alam_flag", alm_flag);
blobmsg_add_string(&outBlob, "lat", lat);
blobmsg_add_string(&outBlob, "lon", lon);
blobmsg_add_string(&outBlob, "acc", acc);
if (invoke_reply_data_cb_ril(origParserId, "gps", "gnss_get_agps", outBlob.head, (ubus_data_handler_t *)gps_usr_callback_hdl, &atHandle, 10000) == UBUS_STATUS_OK)
{
ret = CIRC_SUCCESS;
}
else
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,NULL);
}
blob_buf_free(&outBlob);
}
}
}
}
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+AGNSSGET */
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 AGPSTP_ENABLE
extern int SetAGPSConfig(char *host,unsigned short port, char *username, char *passwd ,int day, int force);
RETURNCODE_T ciAGnssCfg(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 i = 0;
UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
*xid_p = atHandle;
DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_GET_CMD: /* AT+AGNSSCFG? */
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
break;
}
case TEL_EXT_TEST_CMD: /* AT+AGNSSCFG=? */
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+AGNSSCFG: <server>,<port>,<usr>,<passwd>,<day>,<force>\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT+AGNSSCFG= */
{
#define SUPL_SERVER_ADDR_LEN 256
#define MAX_DAY 365
char supl_server[SUPL_SERVER_ADDR_LEN];
INT16 supl_server_len;
memset(supl_server, 0, SUPL_SERVER_ADDR_LEN);
int port = 0;
char username[16];
char passwd[16];
int day = 0;
int force = 0;
memset(username,0,sizeof(username));
memset(passwd,0,sizeof(passwd));
/* Extract the arguments starting with the functionality. */
do {
ret = getExtString(parameter_values_p, 0, supl_server,
SUPL_SERVER_ADDR_LEN, &supl_server_len, NULL);
if (ret != TRUE)
break;
ret = getExtValue(parameter_values_p, 1, &port, 0, 65536, 0);
if (ret != TRUE)
break;
supl_server_len = sizeof(username);
ret = getExtString(parameter_values_p, 2, username, 16,
&supl_server_len, NULL);
if (ret != TRUE)
break;
supl_server_len = sizeof(passwd);
ret = getExtString(parameter_values_p, 3, passwd, 16,
&supl_server_len, NULL);
if (ret != TRUE)
break;
ret = getExtValue(parameter_values_p, 4, &day, 0, MAX_DAY, 0);
if (ret != TRUE)
break;
ret = getExtValue(parameter_values_p, 5, &force, 0, 1, 0);
if (ret != TRUE)
break;
}while(0);
if(ret != TRUE){
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
} else {
if (SetAGPSConfig(supl_server, port, username, passwd, day, force) < 0) {
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED, NULL);
} else {
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
}
}
break;
}
case TEL_EXT_ACTION_CMD: /* AT+AGNSSCFG */
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 ciAGnssSet(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;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_ACTION_CMD: /* AT+AGNSSSET */
{
if (invoke_reply_data_cb_ril(origParserId, "gps", "gnss_set_agps", NULL, (ubus_data_handler_t *)gps_usr_callback_hdl, &atHandle, 4000) == UBUS_STATUS_OK)
{
ret = CIRC_SUCCESS;
}
else
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,NULL);
}
break;
}
default:
{
break;
}
}
/* handle the return value */
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
RETURNCODE_T ciGPSState(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;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_ACTION_CMD: /* AT+GPSST */
{
if (invoke_reply_data_cb_ril(origParserId, "gps", "gnss_get_state", NULL, (ubus_data_handler_t *)gps_state_response_callback, &atHandle, 4000) == UBUS_STATUS_OK)
{
ret = CIRC_SUCCESS;
}
else
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,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);
}
RETURNCODE_T ciGPSSetting(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;
char gps_str[128];
INT16 gps_str_len;
memset(gps_str, 0, 128);
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_GET_CMD: /* AT+GPSSETTING? */
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
break;
}
case TEL_EXT_TEST_CMD: /* AT+GPSSETTING=? */
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSSETTING: <string>\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT+GPSSETTING= */
{
/* Extract the arguments starting with the functionality. */
if (getExtString(parameter_values_p, 0, gps_str, 128, &gps_str_len, NULL) == TRUE)
{
struct blob_buf outBlob;
memset(&outBlob, 0, sizeof(outBlob));
blob_buf_init(&outBlob, 0);
blobmsg_add_string(&outBlob, "gnss_setting_param", gps_str);
if (invoke_noreply_ril(origParserId, "gps", "gnss_setting", outBlob.head) == UBUS_STATUS_OK)
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_OK,0,NULL);
}
else
{
ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,NULL);
}
blob_buf_free(&outBlob);
}
else
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_ACTION_CMD: /* AT+GPSSETTING */
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
#define MBTK_IND_START_FLAG 0xFF
#define MBTK_IND_END_FLAG 0xEE
#define SUPL_SERVER_ADDR_LEN 256
#define MBTK_CMD_RSP_LEN 256
#define GNSS_SOCK_PATH "/tmp/mbtk_gnss_sock"
static int sock_listen_fd = -1;
static char cmd_rsp[MBTK_CMD_RSP_LEN] = {0};
typedef enum {
GNSS_CMD_INIT = 0,
GNSS_CMD_DEINIT,
GNSS_CMD_SETTING,
GNSS_CMD_DL,
GNSS_CMD_AGNSS_GET,
GNSS_CMD_AGNSS_SET
} gnss_cmd_enum;
typedef enum {
GNSS_ERR_OK,
GNSS_ERR_CLI_FULL,
GNSS_ERR_UNKNOWN_HANDLE,
GNSS_ERR_UNSUPPORT,
GNSS_ERR_TIMEOUT,
GNSS_ERR_ARG,
GNSS_ERR_CHECKSUM,
GNSS_ERR_SET_BUSY,
GNSS_ERR_DL_FW,
GNSS_ERR_OPEN_DEV,
GNSS_ERR_FORMAT,
GNSS_ERR_BUSY,
GNSS_ERR_EPH_GET_FAIL,
GNSS_ERR_EPH_INJECT_FAIL,
GNSS_ERR_UNKNOWN
} gnss_err_enum;
#if 1
#include <dlfcn.h>
#define MBTK_LIB_PATH "/lib/libmbtk_lib.so"
typedef unsigned char boolean; /* Boolean value type. */
// typedef unsigned char bool; /* Boolean value type. */
typedef unsigned long long uint64; /* Unsigned 64 bit value */
typedef unsigned long long uint64_t; /* Unsigned 64 bit value */
typedef unsigned int uint32; /* Unsigned 32 bit value */
typedef unsigned int uint32_t; /* Unsigned 32 bit value */
typedef unsigned short uint16; /* Unsigned 16 bit value */
typedef unsigned short uint16_t;
typedef unsigned char uint8; /* Unsigned 8 bit value */
typedef unsigned char uint8_t;
typedef signed long long int64; /* Signed 64 bit value */
typedef signed long long sint64; /* Signed 64 bit value */
typedef signed int int32; /* Signed 32 bit value */
typedef signed int sint32; /* Signed 32 bit value */
typedef signed short int16; /* Signed 16 bit value */
typedef signed short sint16; /* Signed 16 bit value */
typedef signed char int8; /* Signed 8 bit value */
typedef signed char sint8; /* Signed 8 bit value */
typedef unsigned char byte; /* byte type */
typedef enum {
MBTK_MODEM_BAND_AREA_ALL,
MBTK_MODEM_BAND_AREA_CN,
MBTK_MODEM_BAND_AREA_EU,
MBTK_MODEM_BAND_AREA_SA
} mbtk_modem_band_area_enum;
typedef enum {
MBTK_REBOOT_FLAG_NORMAL = 0,
MBTK_REBOOT_FLAG_DOWNLOAD
} mbtk_device_info_reboot_flag_enum;
typedef enum {
MBTK_DEVICE_INFO_ITEM_BASIC = 0,
MBTK_DEVICE_INFO_ITEM_FOTA,
MBTK_DEVICE_INFO_ITEM_MODEM,
MBTK_DEVICE_INFO_ITEM_LOG,
MBTK_DEVICE_INFO_ITEM_NUM
} mbtk_device_info_item_enum;
typedef struct {
uint8 name[16];
uint32 version; // Default : 0x01
uint8 project[16]; // T108 / L508_X6
uint8 project_cust[16]; // T108_C1 / L508_X6_C1 (Refer to: Custom_Model in blf file.)
uint32 ab_support; // 1 for ab
mbtk_device_info_reboot_flag_enum reboot_flag;
uint8 revision_out[48]; // L508_X6v01.01b04.00
uint8 revision_in[64];
uint8 build_time[64];
} mbtk_device_info_basic_t;
typedef struct {
uint8 name[16];
uint32 version; // Default : 0x01
mbtk_modem_band_area_enum band_area;
uint32 band_gsm;
uint32 band_wcdma;
uint32 band_tdlte;
uint32 band_fddlte;
uint32 band_lte_ext;
} mbtk_device_info_modem_t;
static bool dev_info_inited = FALSE;
static mbtk_device_info_basic_t info_basic;
static mbtk_device_info_modem_t info_modem;
typedef int (*mbtk_dev_info_read_func)(mbtk_device_info_item_enum, void *, int);
static int dev_info_get()
{
if(dev_info_inited) {
return 0;
}
void *handle = dlopen(MBTK_LIB_PATH , RTLD_LAZY);
if(handle == NULL)
{
DBGMSG(dev_info_get_S, "dlopen() %s fail : %d", MBTK_LIB_PATH, errno);
return -1;
}
mbtk_dev_info_read_func dev_info_read = (mbtk_dev_info_read_func)dlsym(handle, "mbtk_dev_info_read");
if(dev_info_read == NULL)
{
DBGMSG(dev_info_read_S, "dlsym(mbtk_dev_info_read) fail : %d", errno);
return -1;
}
memset(&info_basic, 0, sizeof(mbtk_device_info_basic_t));
memset(&info_modem, 0, sizeof(mbtk_device_info_modem_t));
// mbtk_dev_info_read()
int result = dev_info_read(MBTK_DEVICE_INFO_ITEM_BASIC, &info_basic, sizeof(mbtk_device_info_basic_t));
if(result) {
DBGMSG(dev_info_read_S, "mbtk_dev_info_read(BASIC) fail.");
return -1;
}
result = dev_info_read(MBTK_DEVICE_INFO_ITEM_MODEM, &info_modem, sizeof(mbtk_device_info_modem_t));
if(result) {
DBGMSG(dev_info_read_S, "mbtk_dev_info_read(MODEM) fail.");
return -1;
}
dev_info_inited = TRUE;
return 0;
}
static char* band_area_2_str(mbtk_modem_band_area_enum band_area)
{
switch(band_area) {
case MBTK_MODEM_BAND_AREA_CN:
return "CN";
case MBTK_MODEM_BAND_AREA_EU:
return "EU";
case MBTK_MODEM_BAND_AREA_SA:
return "SA";
default:
return "DEF";
}
}
#endif
//buf: %cgnss_setting:%d %s%c
static int mbtk_gnss_info_parse(char *data, int len)
{
if(data == NULL || len == 0 || len > MBTK_CMD_RSP_LEN)
{
ERRMSG(mbtk_gnss_parse_1,"[AT_MBTK_GNSS] param error.\n");
return -1;
}
data[len - 1] = 0x0;
char *p = data + 1;
int result = 0;
char temp[MBTK_CMD_RSP_LEN] = {0};
memset(cmd_rsp, 0x0, MBTK_CMD_RSP_LEN);
if(2 == sscanf(p, "gnss_setting:%d %s", &result, temp))
{
if(memcmp(temp, "NULL", 4))
{
memcpy(cmd_rsp, temp, strlen(temp));
}
}
else
{
ERRMSG(mbtk_gnss_parse_2,"[AT_MBTK_GNSS] parse error.\n");
return -1;
}
return result;
}
static CiReturnCode mbtk_gps_err(gnss_err_enum result, UINT32 atHandle)
{
CiReturnCode ret = CIRC_FAIL;
switch(result)
{
case GNSS_ERR_CLI_FULL:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: client full.\r\n");
break;
}
case GNSS_ERR_UNKNOWN_HANDLE:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: unknown handle.\r\n");
break;
}
case GNSS_ERR_UNSUPPORT:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: unsupport.\r\n");
break;
}
case GNSS_ERR_TIMEOUT:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: timeout.\r\n");
break;
}
case GNSS_ERR_ARG:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: param error.\r\n");
break;
}
case GNSS_ERR_CHECKSUM:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: checksum error.\r\n");
break;
}
case GNSS_ERR_SET_BUSY:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: set busy.\r\n");
break;
}
case GNSS_ERR_DL_FW:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: download fail.\r\n");
break;
}
case GNSS_ERR_OPEN_DEV:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: open dev fail.\r\n");
break;
}
case GNSS_ERR_FORMAT:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: format error.\r\n");
break;
}
case GNSS_ERR_BUSY:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: busy.\r\n");
break;
}
case GNSS_ERR_EPH_GET_FAIL:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: eph ser get fail.\r\n");
break;
}
case GNSS_ERR_EPH_INJECT_FAIL:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: agps ser inject fail.\r\n");
break;
}
case GNSS_ERR_UNKNOWN:
default:
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: unknown error.\r\n");
break;
}
}
return ret;
}
static int mbtk_GPS_process(gnss_cmd_enum cmd, void *arg)
{
if(sock_listen_fd < 0) {
sock_listen_fd = socket(AF_LOCAL, SOCK_STREAM, 0);
if(sock_listen_fd < 0)
{
ERRMSG(mbtk_GPS_process_0,"[AT_MBTK_GNSS] socket() fail[%d].\n", errno);
return -1;
}
struct sockaddr_un cli_addr;
memset(&cli_addr, 0, sizeof(cli_addr));
cli_addr.sun_family = AF_LOCAL;
strcpy(cli_addr.sun_path, GNSS_SOCK_PATH);
if(connect(sock_listen_fd, (struct sockaddr *)&cli_addr, sizeof(cli_addr)))
{
ERRMSG(mbtk_GPS_process_1,"[AT_MBTK_GNSS] connect() fail[%d].\n", errno);
close(sock_listen_fd);
sock_listen_fd = -1;
return -1;
}
}
char buff[100] = {0};
char *ptr = NULL;
int len = 0;
int ret_len = 0;
if(cmd == GNSS_CMD_INIT) {
if(arg) {
sprintf(buff, "gnss_init:%d", *(int*)arg);
} else {
return -1;
}
} else if(cmd == GNSS_CMD_DEINIT) {
sprintf(buff, "gnss_deinit");
} else if(cmd == GNSS_CMD_SETTING) {
sprintf(buff, "gnss_setting:%s", (char *)arg);
} else if(cmd == GNSS_CMD_DL) {
sprintf(buff, "gnss_dl:%s", (char *)arg);
} else if(cmd == GNSS_CMD_AGNSS_GET) {
sprintf(buff, "gnss_agnss_get:%s", (char *)arg);
} else if(cmd == GNSS_CMD_AGNSS_SET) {
sprintf(buff, "gnss_agnss_set");
} else {
printf("Unknown cmd.\n");
return -1;
}
ret_len = write(sock_listen_fd, buff, strlen(buff));
if(ret_len < 0)
{
ERRMSG(mbtk_GPS_process_2,"[AT_MBTK_GNSS] write() fail[%d].\n", errno);
return -1;
}
while(1) {
memset(buff, 0, sizeof(buff));
len = read(sock_listen_fd, buff, sizeof(buff));
if(len > 0) {
//buf: %cgnss_init:%d%c
ERRMSG(mbtk_GPS_process_3,"[AT_MBTK_GNSS] RSP : %s\n", buff);
buff[len] = 0;
ptr = buff + 1;
if(cmd == GNSS_CMD_INIT) {
if(memcmp(ptr, "gnss_init", 9) == 0) {
return atoi(ptr + 10);
} else {
ERRMSG(mbtk_GPS_process_4,"[AT_MBTK_GNSS] gnss_init response error.\n");
return -1;
}
} else if(cmd == GNSS_CMD_DEINIT) {
if(memcmp(ptr, "gnss_deinit", 11) == 0) {
return atoi(ptr + 12);
} else {
ERRMSG(mbtk_GPS_process_5,"[AT_MBTK_GNSS] gnss_deinit response error.\n");
return -1;
}
} else if(cmd == GNSS_CMD_SETTING) {
if(memcmp(ptr, "gnss_setting", 12) == 0) { //buf: %cgnss_setting:%d %s%c
return mbtk_gnss_info_parse(buff, len);
} else {
ERRMSG(mbtk_GPS_process_6,"[AT_MBTK_GNSS] gnss_setting response error.\n");
return -1;
}
} else if(cmd == GNSS_CMD_DL) {
if(memcmp(ptr, "gnss_dl", 7) == 0) {
return atoi(ptr + 8);
} else {
ERRMSG(mbtk_GPS_process_7,"[AT_MBTK_GNSS] gnss_dl response error.\n");
return -1;
}
} else if(cmd == GNSS_CMD_AGNSS_GET) {
if(memcmp(ptr, "gnss_agnss_get", 14) == 0) {
return atoi(ptr + 15);
} else {
ERRMSG(mbtk_GPS_process_8,"[AT_MBTK_GNSS] gnss_dl response error.\n");
return -1;
}
} else if(cmd == GNSS_CMD_AGNSS_SET) {
if(memcmp(ptr, "gnss_agnss_set", 14) == 0) {
return atoi(ptr + 15);
} else {
ERRMSG(mbtk_GPS_process_9,"[AT_MBTK_GNSS] gnss_dl response error.\n");
return -1;
}
} else {
ERRMSG(mbtk_GPS_process_10,"[AT_MBTK_GNSS] Unknown response.\n");
return -1;
}
} else if(len == 0) {
ERRMSG(mbtk_GPS_process_11,"[AT_MBTK_GNSS] RSP is null.\n");
return -1;
} else {
ERRMSG(mbtk_GPS_process_12,"[AT_MBTK_GNSS] read = %d:errno = %d\n", len, errno);
}
}
}
RETURNCODE_T mbtk_GPSInit(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;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_TEST_CMD: /* AT+GPSINIT=? */
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSINIT: (0-15)\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT+GPSINIT= */
{
INT32 gps_init_val;
//0-close 1-uart1 2-USB_NAME 4-USB_AT 8-tty_gnss_name
if (getExtValue(parameter_values_p, 0, (int *)&gps_init_val, 0, 15, 0) == TRUE)
{
int result = 0;
result = mbtk_GPS_process(GNSS_CMD_INIT, &gps_init_val);
if (result < 0)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: init fail.\r\n");
}
else if((gnss_err_enum)result == GNSS_ERR_OK)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: init success.\r\n");
}
else
{
ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
}
}
else
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT+GPSINIT? */
case TEL_EXT_ACTION_CMD: /* AT+GPSINIT */
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 mbtk_GPSDeInit(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;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_ACTION_CMD: /* AT+GPSDEINIT */
{
int result = 0;
result = mbtk_GPS_process(GNSS_CMD_DEINIT, NULL);
if (result < 0)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: deinit fail.\r\n");
}
else if((gnss_err_enum)result == GNSS_ERR_OK)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: deinit success.\r\n");
}
else
{
ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
}
break;
}
case TEL_EXT_TEST_CMD: /* AT+GPSDEINIT=? */
case TEL_EXT_GET_CMD: /* AT+GPSDEINIT? */
case TEL_EXT_SET_CMD: /* AT+GPSDEINIT= */
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 mbtk_GPSSleep(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;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_TEST_CMD: /* AT+GPSSLEEP=? */
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSSLEEP: (0,1)\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT+GPSSLEEP= */
{
INT32 gps_sleep_val;
/* Extract the arguments starting with the functionality. */
if (getExtValue(parameter_values_p, 0, (int *)&gps_sleep_val, 0, 1, 0) == TRUE)
{
ret = mbtk_gps_err(GNSS_ERR_UNSUPPORT, atHandle);
}
else
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT+GPSSLEEP? */
case TEL_EXT_ACTION_CMD: /* AT+GPSSLEEP */
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 mbtk_AGnssGet(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;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_TEST_CMD: /* AT+AGNSSGET=? */
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+AGNSSGET: <eph_type>, <alam_flag>\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT+AGNSSGET= */
{
int eph_type = 0;
int alm_flag = 0;
char param[128] = {0};
/* Extract the arguments starting with the functionality. */
if (getExtValue(parameter_values_p, 0, &eph_type, 0, 6, 0) == TRUE)
{
if (getExtValue(parameter_values_p, 1, &alm_flag, 0, 1, 0) == TRUE)
{
int result = 0;
snprintf(param, 128, "%d,%d", eph_type, alm_flag);
result = mbtk_GPS_process(GNSS_CMD_AGNSS_GET, param);
if (result < 0)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: agps get eph fail.\r\n");
}
else if((gnss_err_enum)result == GNSS_ERR_OK)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: agps get eph success.\r\n");
}
else
{
ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
}
}
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+AGNSSGET? */
case TEL_EXT_ACTION_CMD: /* AT+AGNSSGET */
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 mbtk_AGnssCfg(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 i = 0;
UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
*xid_p = atHandle;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_TEST_CMD: /* AT+AGNSSCFG=? */
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+AGNSSCFG: <server>,<port>,<usr>,<passwd>,<day>,<force>\r\n");
break;
}
case TEL_EXT_GET_CMD: /* AT+AGNSSCFG? */
case TEL_EXT_SET_CMD: /* AT+AGNSSCFG= */
case TEL_EXT_ACTION_CMD: /* AT+AGNSSCFG */
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 mbtk_AGnssSet(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;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_ACTION_CMD: /* AT+AGNSSSET */
{
int result = 0;
result = mbtk_GPS_process(GNSS_CMD_AGNSS_SET, NULL);
if (result < 0)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: agps inject fail.\r\n");
}
else if((gnss_err_enum)result == GNSS_ERR_OK)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: agps inject success.\r\n");
}
else
{
ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
}
break;
}
case TEL_EXT_TEST_CMD: /* AT+AGNSSSET=? */
case TEL_EXT_GET_CMD: /* AT+AGNSSSET? */
case TEL_EXT_SET_CMD: /* AT+AGNSSSET= */
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 mbtk_GPSState(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;
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_ACTION_CMD: /* AT+GPSST */
{
ret = mbtk_gps_err(GNSS_ERR_UNSUPPORT, atHandle);
break;
}
case TEL_EXT_TEST_CMD: /* AT+AGNSSCFG=? */
case TEL_EXT_GET_CMD: /* AT+AGNSSCFG? */
case TEL_EXT_SET_CMD: /* AT+AGNSSCFG= */
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 mbtk_GPSSetting(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;
char gps_str[128];
INT16 gps_str_len;
memset(gps_str, 0, 128);
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_TEST_CMD: /* AT+GPSSETTING=? */
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSSETTING: <string>\r\n");
break;
}
case TEL_EXT_SET_CMD: /* AT+GPSSETTING= */
{
/* Extract the arguments starting with the functionality. */
if (getExtString(parameter_values_p, 0, gps_str, 127, &gps_str_len, NULL) == TRUE)
{
int result = 0;
result = mbtk_GPS_process(GNSS_CMD_SETTING, gps_str);
if (result < 0)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: setting fail.\r\n");
}
else if((gnss_err_enum)result == GNSS_ERR_OK)
{
char temp[512] = {0};
if(strlen(cmd_rsp))
{
snprintf(temp, 512, "+GPS INFO: %s\r\n", cmd_rsp);
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, temp);
}
else
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: setting success.\r\n");
}
}
else
{
ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
}
}
else
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT+GPSSETTING? */
case TEL_EXT_ACTION_CMD: /* AT+GPSSETTING */
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 mbtk_GPSFwdl(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;
char gps_str[128];
INT16 gps_str_len;
memset(gps_str, 0, 128);
int band = -1;
char* bd = "gp_bd_ga";
char* gl = "gp_gl_ga";
/*
** Check the format of the request.
*/
if(InProduction_Mode() == 0)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: fwdl mode fail.\r\n");
rc = HANDLE_RETURN_VALUE(ret);
return(rc);
}
switch(op)
{
case TEL_EXT_TEST_CMD: /* AT+GPSFWDL=? */
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSFWDL: <string>\r\n");
break;
}
case TEL_EXT_ACTION_CMD: /* AT+GPSFWDL */
{
if(!dev_info_get())
{
//Default bd
band = info_modem.band_area;
if(band == MBTK_MODEM_BAND_AREA_EU)
strncpy(gps_str, gl, strlen(gl));
else
strncpy(gps_str, bd, strlen(bd));
}
//ATRESP(atHandle, ATCI_RESULT_CODE_NULL, 0, gps_str);
if (band != -1)
{
int result = 0;
result = mbtk_GPS_process(GNSS_CMD_DL, gps_str);
if (result < 0)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: fwdl fail.\r\n");
}
else if((gnss_err_enum)result == GNSS_ERR_OK)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: fwdl success.\r\n");
}
else
{
ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
}
}
else
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_SET_CMD: /* AT+GPSFWDL= */
{
/* Extract the arguments starting with the functionality. */
if (getExtString(parameter_values_p, 0, gps_str, 127, &gps_str_len, NULL) == TRUE)
{
int result = 0;
result = mbtk_GPS_process(GNSS_CMD_DL, gps_str);
if (result < 0)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: fwdl fail.\r\n");
}
else if((gnss_err_enum)result == GNSS_ERR_OK)
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: fwdl success.\r\n");
}
else
{
ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
}
}
else
{
ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
}
break;
}
case TEL_EXT_GET_CMD: /* AT+GPSFWDL? */
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 ciCMTLRA(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 sAtpIndex = *(TelAtParserID *)arg_p;
int allow = 0;
int id = 0;
UINT8 *pAllow = NULL;
UINT8 *pHandleID = NULL;
char rspBuf[40] = {0};
UINT32 IndHandler = IND_REQ_HANDLE;
*xid_p = atHandle;
if (!GET_SIM1_FLAG(atHandle)) {
pAllow = &gCmtlrAllow[sAtpIndex];
pHandleID = &gCmtlrHandleID[sAtpIndex];
IndHandler = IND_REQ_HANDLE;
} else {
pAllow = &gCmtlrAllow[sAtpIndex];
pHandleID = &gCmtlrHandleID[sAtpIndex];
IndHandler = IND_REQ_HANDLE_1;
}
//DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
/*
** Check the format of the request.
*/
switch(op)
{
case TEL_EXT_GET_CMD: /* AT+CMTLRA? */
{
snprintf(rspBuf, sizeof(rspBuf), "+CMTLRA: %d,%d", *pAllow, *pHandleID);
ret = ATRESP(atHandle,ATCI_RESULT_CODE_OK,0,rspBuf);
break;
}
case TEL_EXT_SET_CMD: /* AT+CMTLRA= */
{
if (getExtValue(parameter_values_p, 0, &allow, 0, 1, 0) == TRUE)
{
if (getExtValue(parameter_values_p, 1, &id, 0, 255, 0) == TRUE)
{
*pAllow = allow;
*pHandleID = id;
snprintf(rspBuf, sizeof(rspBuf), "+CMTLRA: %d,%d", *pAllow, *pHandleID);
ATRESP(IndHandler,0,0,rspBuf);
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);
}