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]
b.liue9582032025-04-17 19:18:16 +0800[diff] [blame]1/*--------------------------------------------------------------------------------------------------------------------
2 (C) Copyright 2006, 2007 Marvell DSPC Ltd. All Rights Reserved.
3 -------------------------------------------------------------------------------------------------------------------*/
4
5#include "ci_api_types.h"
6#include "ci_api.h"
7#include "teldef.h"
8#include "telconfig.h"
9#include "telatci.h"
10#include "telatparamdef.h"
11#include "telutl.h"
12#include <stdio.h>
13#include <teldef.h>
14#include <fcntl.h>
15
b.liu37ac3842025-05-26 21:22:12 +0800[diff] [blame]16// Add by mbtk
17#include <stdlib.h>
18#include <unistd.h>
19#include <errno.h>
20#include <sys/socket.h>
21#include <sys/un.h>
22#include <netinet/in.h>
23#include <pthread.h>
24#include <sys/epoll.h>
25// End by mbtk
b.liue9582032025-04-17 19:18:16 +0800[diff] [blame]26#if defined (BIONIC)
27#include <cutils/properties.h>
28#endif
29
30#if defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
31#include "ursp_inner.h"
32#endif
33extern AtciCharacterSet chset_type[];
34extern AtciCharacterSet chset_type_1[];
35extern BOOL isGsmChset[];
36extern BOOL isGsmChset_1[];
37
38extern CiShHandle gAtciShellHandle;
39extern CiShHandle gAtciShReqHandle;
40extern CiServiceHandle gAtciSvgHandle[CI_SG_NUMIDS + 1];
41extern int loglevel;
42
43extern void ciClientStubDeinit(void);
44
45UINT8 gCmtlrAllow[NUM_OF_TEL_ATP] = {0};
46UINT8 gCmtlrHandleID[256] = {0};
47
48UINT8 gCmtlrAllow_1[NUM_OF_TEL_ATP] = {0};
49UINT8 gCmtlrHandleID_1[256] = {0};
50
51#define MAX_DUMP_LENGTH 160
52
53void dbg_dump_buffer(char* name, char* buf, int len)
54{
55 int i;
56 char dbgBuf[TEL_AT_CMDSTR_MAX_LEN], tempBuf[10];;
57
58 sprintf(dbgBuf, "Dump \"%s\" Buffer [len=%d]: \n", name, len);
59 for (i = 0; i < len && i < MAX_DUMP_LENGTH; i++)
60 {
61 sprintf(tempBuf, "%02X", (UINT8)buf[i]);
62 strcat(dbgBuf, tempBuf);
63 if (((i + 1) % 32) == 0) strcat(dbgBuf, "\n");
64 }
65 strcat(dbgBuf, "\n");
66 eeh_log(0, LOG_NOTICE, "%s", dbgBuf);
67}
68
69void dbg_dump_string(char* name, char* buf, int len)
70{
71 int i;
72 char dbgBuf[TEL_AT_CMDSTR_MAX_LEN], tempBuf[10];;
73
74 sprintf(dbgBuf, "Dump \"%s\" Buffer [len=%d]: \n", name, len);
75 for (i = 0; i < len && i < MAX_DUMP_LENGTH; i++)
76 {
77 sprintf(tempBuf, "%c", buf[i]);
78 strcat(dbgBuf, tempBuf);
79 if (((i + 1) % 32) == 0) strcat(dbgBuf, "\n");
80 }
81 strcat(dbgBuf, "\n");
82 eeh_log(0, LOG_VERBOSE, "%s", dbgBuf);
83
84}
85
86/******************************************************************************
87* Debugging AT Command
88******************************************************************************/
89
90
91/*******************************************************************
92* FUNCTION: vHDL
93*
94* DESCRIPTION: Get Handlle value for debugging
95*
96* PARAMETERS:
97*
98* RETURNS:
99*
100*******************************************************************/
101utlReturnCode_T vHDL( const utlAtParameterOp_T op,
102 const char *command_name_p,
103 const utlAtParameterValue_P2c parameter_values_p,
104 const size_t num_parameters,
105 const char *info_text_p,
106 unsigned int *xid_p,
107 void *arg_p)
108{
109 UNUSEDPARAM(command_name_p)
110 UNUSEDPARAM(parameter_values_p)
111 UNUSEDPARAM(num_parameters)
112 UNUSEDPARAM(info_text_p)
113
114 _CiServiceGroupId ciSvcGrpId;
115 *xid_p = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
116
117 if ( op == utlAT_PARAMETER_OP_GET)
118 {
119 VDBGMSG(vHDL, "this is get operation.\n");
120 }
121 else if ( op == utlAT_PARAMETER_OP_SET)
122 {
123 VDBGMSG(vHDL1, "this is set operation.\n");
124 }
125
126 for ( ciSvcGrpId = CI_SG_ID_CC; ciSvcGrpId <= CI_SG_NUMIDS; ciSvcGrpId++ )
127 {
128 DBGMSG(vHDL2, "ShellHandle[%d]: %d \r\n", ciSvcGrpId, gAtciSvgHandle[ciSvcGrpId]);
129 }
130
131 ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
132 return utlSUCCESS;
133
134}
135
136/*******************************************************************
137* FUNCTION: vECHO
138*
139* DESCRIPTION: echo back whatever type in the first arg
140*
141* PARAMETERS:
142*
143* RETURNS:
144*
145*******************************************************************/
146utlReturnCode_T vECHO( const utlAtParameterOp_T op,
147 const char *command_name_p,
148 const utlAtParameterValue_P2c parameter_values_p,
149 const size_t num_parameters,
150 const char *info_text_p,
151 unsigned int *xid_p,
152 void *arg_p)
153{
154 UNUSEDPARAM(op)
155 UNUSEDPARAM(command_name_p)
156
157 UNUSEDPARAM(num_parameters)
158 UNUSEDPARAM(info_text_p)
159 int i;
160 char tmp[255];
161
162 *xid_p = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
163
164 sprintf(tmp, "%s", parameter_values_p[0].value.string_p);
165
166 /* convert '-' to ',' */
167 for (i = 0; i < (int)strlen(tmp); i++)
168 {
169 if (tmp[i] == '-')
170 tmp[i] = ',';
171 }
172
173 ATRESP( *xid_p, ATCI_RESULT_CODE_OK, 0, tmp);
174
175 return utlSUCCESS;
176
177}
178
179
180/* debugging function for linux */
181
182/******************************************************************************
183* Command not implemented (faking for Qtopia Integration
184******************************************************************************/
185
186utlReturnCode_T ciCSCS( const utlAtParameterOp_T op,
187 const char *command_name_p,
188 const utlAtParameterValue_P2c parameter_values_p,
189 const size_t num_parameters,
190 const char *info_text_p,
191 unsigned int *xid_p,
192 void *arg_p)
193{
194 RETURNCODE_T rc = INITIAL_RETURN_CODE;
195 CiReturnCode ret = CIRC_FAIL;
196
197 UNUSEDPARAM(op)
198 UNUSEDPARAM(command_name_p)
199 UNUSEDPARAM(parameter_values_p)
200 UNUSEDPARAM(num_parameters)
201 UNUSEDPARAM(info_text_p)
202 /*
203 * Put parser index into the variable
204 */
205 CiRequestHandle atHandle;
206 TelAtParserID sAtpIndex=TEL_AT_CMD_ATP_0;
207 AtciCharacterSet *pchset_type;
208 BOOL *pIsGsmChset;
209
210 sAtpIndex = *(TelAtParserID *)arg_p;
211 atHandle = MAKE_AT_HANDLE( sAtpIndex );
212 *xid_p = atHandle;
213
214 if (!GET_SIM1_FLAG(atHandle)) {
215 pchset_type = &chset_type[sAtpIndex];
216 pIsGsmChset = &isGsmChset[sAtpIndex];
217 } else {
218 pchset_type = &chset_type_1[sAtpIndex];
219 pIsGsmChset = &isGsmChset_1[sAtpIndex];
220 }
221
222 /*
223 * process operation
224 */
225 switch(op)
226 {
227 case TEL_EXT_SET_CMD: /* AT+CSCS= */
228 {
229 char chset[10];
230 INT16 len=0;
231
232 memset(chset, 0, sizeof(chset));
233
234 if( getExtString( parameter_values_p, 0, (CHAR *)chset, 9, &len, NULL ) == TRUE )
235 {
236 if(strcmp(chset, "IRA") == 0){
237 *pIsGsmChset = FALSE;
238 *pchset_type = ATCI_CHSET_IRA;
239 ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
240 }
241 else if(strcmp(chset, "UCS2") == 0){
242 *pIsGsmChset = FALSE;
243 *pchset_type = ATCI_CHSET_UCS2;
244 ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
245 }
246 else if(strcmp(chset, "HEX") == 0){
247 *pIsGsmChset = FALSE;
248 *pchset_type = ATCI_CHSET_HEX;
249 ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
250 }
251 // GSM chset is not implemented, just make workaround
252 else if(strcmp(chset, "GSM") == 0){
253 *pIsGsmChset = TRUE;
254 *pchset_type = ATCI_CHSET_IRA;
255 ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
256 }
257 else
258 ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
259 }
260 else
261 ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
262
263 break;
264 }
265
266 case TEL_EXT_TEST_CMD: /* AT+CSCS=? */
267 {
268 //coverity[string_null:SUPPRESS]
269 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CSCS: (\"IRA\",\"UCS2\",\"HEX\",\"GSM\")\r\n");
270 break;
271 }
272 case TEL_EXT_GET_CMD: /* AT+CSCS? */
273 {
274 if(*pIsGsmChset)
275 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CSCS: \"GSM\"\r\n");
276 else if(*pchset_type == ATCI_CHSET_IRA)
277 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CSCS: \"IRA\"\r\n");
278 else if(*pchset_type == ATCI_CHSET_UCS2) //coverity[string_null:SUPPRESS]
279 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CSCS: \"UCS2\"\r\n");
280 else if(*pchset_type == ATCI_CHSET_HEX)
281 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+CSCS: \"HEX\"\r\n");
282 else
283 ret = ATRESP( atHandle,ATCI_RESULT_CODE_ERROR,0,NULL);
284
285 break;
286 }
287
288 default:
289 ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
290 break;
291 }
292
293 /* handle the return value */
294 rc = HANDLE_RETURN_VALUE(ret);
295 return(rc);
296}
297
298/************************************************************************************
299 * F@: ciStarCSCS - GLOBAL API for GCF AT*CSCS command
300 *
301 * Select CSCS setting from proxy
302 *
303 */
304RETURNCODE_T ciStarCSCS( const utlAtParameterOp_T op,
305 const char *command_name_p,
306 const utlAtParameterValue_P2c parameter_values_p,
307 const size_t num_parameters,
308 const char *info_text_p,
309 unsigned int *xid_p,
310 void *arg_p)
311
312{
313 RETURNCODE_T rc = INITIAL_RETURN_CODE;
314 CiReturnCode ret = CIRC_FAIL;
315
316 UNUSEDPARAM(op)
317 UNUSEDPARAM(command_name_p)
318 UNUSEDPARAM(parameter_values_p)
319 UNUSEDPARAM(num_parameters)
320 UNUSEDPARAM(info_text_p)
321 /*
322 * Put parser index into the variable
323 */
324 CiRequestHandle atHandle=0;
325 TelAtParserID sAtpIndex=TEL_AT_CMD_ATP_0;
326 AtciCharacterSet *pchset_type;
327 BOOL *pIsGsmChset;
328 int proxyID=0;
329 CHAR AtRspBuf [30] = {0};
330
331 sAtpIndex = * (TelAtParserID *) arg_p;
332 atHandle = MAKE_AT_HANDLE( sAtpIndex );
333 *xid_p = atHandle;
334
335 /*
336 * process operation
337 */
338 switch(op)
339 {
340 case TEL_EXT_SET_CMD: /* AT+CSCS= */
341 {
342 char chset[10] = {0};
343 INT16 len=0;
344
345 if ( getExtValue(parameter_values_p, 0, &proxyID, 0, 0x7FFFFFFF, 0) == TRUE )
346 {
347 UINT32 atHandle_prxy = GET_AT_HANDLE(proxyID);
348 TelAtParserID sAtpIndex_prxy = (TelAtParserID)(GET_ATP_INDEX(atHandle_prxy));
349
350 DBGMSG(ciStarCSCS0, "%s: proxyID %d, chset_type %d, isGsmChset %d\n", __FUNCTION__, proxyID, chset_type[sAtpIndex_prxy], isGsmChset[sAtpIndex_prxy]);
351
352 pchset_type = &chset_type[sAtpIndex_prxy];
353 pIsGsmChset = &isGsmChset[sAtpIndex_prxy];
354
355 if (parameter_values_p[1].is_default)
356 {
357 /*get*/
358 if(*pIsGsmChset)
359 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CSCS: \"GSM\"\r\n");
360 else if(*pchset_type == ATCI_CHSET_IRA)
361 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CSCS: \"IRA\"\r\n");
362 else if(*pchset_type == ATCI_CHSET_UCS2)//coverity[string_null:SUPPRESS]
363 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CSCS: \"UCS2\"\r\n");
364 else if(*pchset_type == ATCI_CHSET_HEX)
365 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CSCS: \"HEX\"\r\n");
366 else
367 ret = ATRESP( atHandle,ATCI_RESULT_CODE_ERROR,0,NULL);
368
369 break;
370 }
371
372 if( getExtString( parameter_values_p, 1, (CHAR *)chset, 9, &len, NULL ) == TRUE )
373 {
374 if(strcmp(chset, "IRA") == 0){
375 *pIsGsmChset = FALSE;
376 *pchset_type = ATCI_CHSET_IRA;
377 ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
378 }
379 else if(strcmp(chset, "UCS2") == 0){
380 *pIsGsmChset = FALSE;
381 *pchset_type = ATCI_CHSET_UCS2;
382 ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
383 }
384 else if(strcmp(chset, "HEX") == 0){
385 *pIsGsmChset = FALSE;
386 *pchset_type = ATCI_CHSET_HEX;
387 ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
388 }
389 // GSM chset is not implemented, just make workaround
390 else if(strcmp(chset, "GSM") == 0){
391 *pIsGsmChset = TRUE;
392 *pchset_type = ATCI_CHSET_IRA;
393 ret = ATRESP( atHandle,ATCI_RESULT_CODE_OK,0,NULL);
394 }
395 else
396 ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
397 }
398 else
399 ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
400 }
401 else
402 ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_INVALID_PARAM,NULL);
403 break;
404 }
405
406 case TEL_EXT_TEST_CMD: /* AT+CSCS=? */
407 {
408 //coverity[string_null:SUPPRESS]
409 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CSCS: proxyID[,(\"IRA\",\"UCS2\",\"HEX\",\"GSM\")]\r\n");
410 break;
411 }
412
413 default:
414 ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
415 break;
416 }
417
418 /* handle the return value */
419 rc = HANDLE_RETURN_VALUE(ret);
420 return(rc);
421}
422
423/************************************************************************************
424 * F@: cciReg - GLOBAL API for GCF AT*CCIREG command
425 *
426 */
427RETURNCODE_T cciReg( const utlAtParameterOp_T op,
428 const char *command_name_p,
429 const utlAtParameterValue_P2c parameter_values_p,
430 const size_t num_parameters,
431 const char *info_text_p,
432 unsigned int *xid_p,
433 void *arg_p)
434{
435 UNUSEDPARAM(command_name_p)
436 UNUSEDPARAM(num_parameters)
437 UNUSEDPARAM(info_text_p)
438 UNUSEDPARAM(xid_p)
439 UNUSEDPARAM(arg_p)
440 /*
441 ** Set the result code to INITIAL_RETURN_CODE. This allows
442 ** the indications to display the correct return code after the
443 ** AT Command is issued.
444 */
445 RETURNCODE_T rc = INITIAL_RETURN_CODE;
446 BOOL cmdValid = FALSE;
447 int regState;
448 UINT8 sgId;
449 static CiShOperDeregisterDefaultSgReq gDefDeregBuf;
450 static CiShOperDeregisterSgReq gSvgDeregBuf;
451 UINT32 atHandle = MAKE_AT_HANDLE(*(TelAtParserID *)arg_p);
452
453 *xid_p = atHandle;
454
455 /*
456 * process operation
457 */
458 switch ( op )
459 {
460 case TEL_EXT_TEST_CMD: /* AT*CCIREG=? */
461 {
462 /* No CI primitive for this: print hard-coded reply */
463 ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"*CCIREG: 0" );
464 cmdValid = TRUE;
465 break;
466 }
467 /*
468 case TEL_EXT_GET_CMD: // AT*CCIREG?
469 {
470 // return CCI REg status
471 cmdValid = TRUE;
472 break;
473 }
474 */
475 case TEL_EXT_SET_CMD: /* AT*CCIREG= */
476 {
477 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 )
478 {
479 if (regState == 0)
480 {
481 WARNMSG(cciReg, "DeRegister the default service group\n");
482 /* DeRegister the default service group. */
483 gDefDeregBuf.defHandle = gAtciShellHandle;
484
485 rc = ciShRequest( gAtciShellHandle, /* Shell Handle */
486 CI_SH_OPER_DEREGISTERDEFSG, /* Operation */
487 &gDefDeregBuf, /* parameters */
488 gAtciShReqHandle++ ); /* Opaque handle */
489
490 //DBGMSG(cciReg2, "DeRegister the service groups\n");
491 // deregister CCI service groups
492 for (sgId = CI_SG_ID_CC; sgId < CI_SG_NUMIDS; sgId++)
493 {
494 gSvgDeregBuf.handle = gAtciSvgHandle[sgId];
495 rc = ciShRequest( gAtciShellHandle, /* Shell Handle */
496 CI_SH_OPER_DEREGISTERSG, /* Operation */
497 &gSvgDeregBuf, /* parameters */
498 gAtciShReqHandle++ ); /* Opaque handle */
499 }
500 //DBGMSG(cciReg3, "DeRegister the shell\n");
501 // deregister shell
502 rc = ciShDeregisterReq(gAtciShellHandle, gAtciShReqHandle++);
503 sleep(1000);
504 WARNMSG(cciReg4, "Deinit ci client\n");
505 ciClientStubDeinit();
506 }
507 else
508 {
509 //WARNMSG(cciReg5, "to be implemented!!!\n");
510 }
511 cmdValid = TRUE;
512 }
513 break;
514 }
515
516 default:
517 {
518 break;
519 }
520 }
521
522 if ( !cmdValid )
523 {
524 ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
525 }
526 else
527 rc = utlSUCCESS;
528
529
530
531 return(rc);
532
533}
534
535/*******************************************************************
536* FUNCTION: vDump
537*
538* DESCRIPTION: Used to dump the loglevel
539*
540* PARAMETERS:
541*
542* RETURNS:
543*
544*******************************************************************/
545utlReturnCode_T vDump( const utlAtParameterOp_T op,
546 const char *command_name_p,
547 const utlAtParameterValue_P2c parameter_values_p,
548 const size_t num_parameters,
549 const char *info_text_p,
550 unsigned int *xid_p,
551 void *arg_p)
552{
553 UNUSEDPARAM(command_name_p)
554 UNUSEDPARAM(parameter_values_p)
555 UNUSEDPARAM(num_parameters)
556 UNUSEDPARAM(info_text_p)
557
558 TelAtParserID sAtpIndex;
559 sAtpIndex = *(TelAtParserID *)arg_p;
560 *xid_p = MAKE_AT_HANDLE(sAtpIndex);
561 CiReturnCode ret = CIRC_FAIL;
562 RETURNCODE_T rc = INITIAL_RETURN_CODE;
563 int level;
564 switch ( op )
565 {
566 case TEL_EXT_GET_CMD: /* AT+VDUMP? */
567 {
568 char buf[50];
569 sprintf(buf, "+VDUMP: %d", get_log_level());
570 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, buf);
571 break;
572 }
573
574 case TEL_EXT_SET_CMD: /* AT+VDUMP= */
575 {
576 if ( getExtValue( parameter_values_p, 0, &level, TELEPHONY_MODULE_LOG_SILENT, TELEPHONY_MODULE_LOG_DEBUG, TELEPHONY_MODULE_LOG_NOTICE) == TRUE )
577 {
578 set_telephony_default_log_level(level);
579 set_log_level(level);
580 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
581 }
582 else
583 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
584 break;
585 }
586 default:
587 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
588 break;
589 }
590
591 /* handle the return value */
592 rc = HANDLE_RETURN_VALUE(ret);
593
594 return(rc);
595}
596
597/*******************************************************************
598* FUNCTION: vDump
599*
600* DESCRIPTION: Used to dump the loglevel
601*
602* PARAMETERS:
603*
604* RETURNS:
605*
606*******************************************************************/
607utlReturnCode_T vLog( const utlAtParameterOp_T op,
608 const char *command_name_p,
609 const utlAtParameterValue_P2c parameter_values_p,
610 const size_t num_parameters,
611 const char *info_text_p,
612 unsigned int *xid_p,
613 void *arg_p)
614{
615 UNUSEDPARAM(command_name_p)
616 UNUSEDPARAM(parameter_values_p)
617 UNUSEDPARAM(num_parameters)
618 UNUSEDPARAM(info_text_p)
619
620 TelAtParserID sAtpIndex;
621 int log = 0, para = 0, para2 = 0;
622 char buf[100];
623 sAtpIndex = *(TelAtParserID *)arg_p;
624 *xid_p = MAKE_AT_HANDLE(sAtpIndex);
625 CiReturnCode ret = CIRC_FAIL;
626 RETURNCODE_T rc = INITIAL_RETURN_CODE;
627
628 switch ( op )
629 {
630 case TEL_EXT_GET_CMD: /* AT+log? */
631 {
632 sprintf(buf, "+log: %d, %d", log, para);
633 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, buf);
634 break;
635 }
636
637 case TEL_EXT_SET_CMD: /* AT+log=*/
638 {
639 if ( getExtValue( parameter_values_p, 0, &log, 0, 255, 0) == TRUE )
640 {
641 if ( getExtValue( parameter_values_p, 1, &para, 0, 255, 0) == TRUE )
642 {
643 switch (log)
644 {
645 case 1:
646 {
647 unsigned int seek = 0, data[2] = {0};
648 FILE *fd;
649
650 if ( getExtValue( parameter_values_p, 2, &para2, 0, 0x6000000, 0) != TRUE )
651 {
652 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, "Get ext valur error" );
653 break;
654 }
655 else
656 {
657 data[1] = para2;
658 }
659
660 switch(para)
661 {
662 case 0:
663 {
664 data[0] = 0x50686565; //eehP
665 seek = 52;
666 break;
667 }
668
669 case 1:
670 {
671 data[0] = 0x52535043; //cpsr
672 seek = 60;
673 break;
674 }
675
676 case 2:
677 {
678 data[0] = 0x4B574148; //hawk
679 seek = 68;
680 break;
681 }
682
683 case 3:
684 {
685 data[0] = 0x44534D49; //imsd
686 seek = 76;
687 break;
688 }
689
690 case 4:
691 {
692 data[0] = 0x45504950; //pipe
693 seek = 84;
694 break;
695 }
696
697 case 5:
698 {
699 data[0] = 0x54534146; //fast
700 seek = 92;
701 break;
702 }
703
704 case 6:
705 {
706 data[0] = 0x464D5041; //apmf
707 seek = 100;
708 break;
709 }
710
711 case 7:
712 {
713 data[0] = 0x00444950; //pid
714 seek = 108;
715 break;
716 }
717
718 case 8:
719 {
720 data[0] = 0x00444956; //vid
721 seek = 116;
722 break;
723 }
724
725 case 9:
726 {
727 data[0] = 0x444D424F; //obmd
728 seek = 124;
729 break;
730 }
731
732 default:
733 {
734 data[0] = 0x444D424F; //obmd
735 seek = 124;
736 break;
737 }
738 }
739
740 /* Preparing file */
741 fd = fopen("/tmp_log_file.bin", "wb");
742 if (!fd) {
743 ret = ATRESP( *xid_p,ATCI_RESULT_CODE_CME_ERROR,CMS_UNKNOWN_ERROR,"Open file error");
744 break;
745 }
746
747 ret = fwrite(&data, sizeof(data), 1, fd);
748 if (ret != 1) {
749 fclose(fd);
750 ret = ATRESP( *xid_p,ATCI_RESULT_CODE_CME_ERROR,CMS_UNKNOWN_ERROR,"write file error");
751 break;
752 }
753 fclose(fd);
754
755 /* Preparing to write to flash */
756 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);
757 if (ret >= 100) {
758 ret = ATRESP( *xid_p,ATCI_RESULT_CODE_CME_ERROR,CMS_UNKNOWN_ERROR,"snprintf length error");
759 break;
760 }
761
762 /* Writing to flash with DD */
763 ret = system(buf);
764 if (ret == -1) {
765 ret = ATRESP( *xid_p,ATCI_RESULT_CODE_CME_ERROR,CMS_UNKNOWN_ERROR,"DD command error");
766 break;
767 }
768
769 sync();
770
771 /* Removing temp file */
772 ret = remove("/tmp_log_file.bin");
773 if (ret) {
774 ret = ATRESP( *xid_p,ATCI_RESULT_CODE_CME_ERROR,CMS_UNKNOWN_ERROR,"Remove file error");
775 break;
776 }
777 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
778 break;
779 }
780
781 case 2:
782 {
783 cp_set_ddr_flag(0x00, 0x444D424F);
784 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
785 break;
786 }
787
788 case 4: // AP crash
789 {
790 switch(para)
791 {
792 case 0:
793 {
794 ASSERT(0);
795 break;
796 }
797
798 case 1:
799 {
800 ERRMSG(DBG, "%s: AP crash 1", __FUNCTION__);
801 *(volatile unsigned int *)0xFFFFFFFF = 0;
802 ERRMSG(DBG, "%s: AP crash 2", __FUNCTION__);
803 break;
804 }
805
806 default:
807 {
808 int fd = -1;
809
810 //echo B > /dev/ramdump_ctl
811 fd = open("/dev/ramdump_ctl", O_RDWR | O_SYNC);
812 if (fd >= 0) {
813 write(fd, "B", 1);
814 close(fd);
815 }
816 break;
817 }
818 }
819 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
820 break;
821 }
822
823 case 14: // CP Assert
824 {
825 int fd = -1;
826
827 //echo a > /dev/acipc
828 fd = open("/dev/acipc", O_RDWR | O_SYNC);
829 if (fd >= 0) {
830 write(fd, "a", 1);
831 close(fd);
832 }
833 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
834 break;
835 }
836 case 15:
837 {
838 #if defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
839 ursp_init();
840 #endif
841 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
842 break;
843 }
844 case 16: //
845 {
846 CHAR returnStr[40] = {0};
847 if ( getExtUValue( parameter_values_p, 2, &para2, 0, 0xFFFFFFFF, 0) != TRUE ) // len
848 {
849 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
850 break;
851 }
852
853 switch(para)
854 {
855 case 0: // don't rest diag buffer length
856 {
857 sprintf(buf, "echo %llu,0 > /proc/DiagDev_Debug/diagbuf_len", para2<<20);
858 executeShellCMD(buf, returnStr);
859 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
860 break;
861 }
862
863 case 1: //rest diag buffer length
864 {
865 sprintf(buf, "echo %llu,1 > /proc/DiagDev_Debug/diagbuf_len", para2<<20);
866 executeShellCMD(buf, returnStr);
867 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
868 break;
869 }
870
871 case 2: //read
872 {
873 executeShellCMD("cat /proc/DiagDev_Debug/diagbuf_len", returnStr);
874 ret = ATRESP(*xid_p,ATCI_RESULT_CODE_OK,0,returnStr);
875 break;
876 }
877
878 default:
879 {
880 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
881 break;
882 }
883 }
884 break;
885 }
886
887 default:
888 {
889 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
890 break;
891 }
892 }
893 }
894 else
895 {
896 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
897 }
898
899 }
900 else
901 {
902 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
903 }
904 break;
905 }
906
907 default:
908 {
909 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
910 break;
911 }
912 }
913
914 /* handle the return value */
915 rc = HANDLE_RETURN_VALUE(ret);
916
917 return(rc);
918}
919
920/* End Fake commands for Qtopia Integration*/
921
922
923#if defined(ATCMD_1901_CI) || defined(ATCMD_1903_CI)
924utlReturnCode_T ciAPPSTART( const utlAtParameterOp_T op,
925 const char *command_name_p,
926 const utlAtParameterValue_P2c parameter_values_p,
927 const size_t num_parameters,
928 const char *info_text_p,
929 unsigned int *xid_p,
930 void *arg_p)
931{
932 RETURNCODE_T rc = INITIAL_RETURN_CODE;
933 CiReturnCode ret = CIRC_FAIL;
934 int mode = 0;
935 CHAR osId[MAX_LEN_OF_OS_ID] = {0};
936 INT16 osIdLen = 0;
937 CHAR appId[MAX_LEN_OF_OS_APP_ID + 1] = {0};
938 INT16 appIdLen = 0;
939 CHAR ipv4Addr[CI_PS_PDP_IP_V4_SIZE + 1] = {0};
940 INT16 ipv4AddrLen = 0;
941 CHAR ipv6Addr[CI_PS_PDP_IP_V6_SIZE + 1] = {0};
942 INT16 ipv6AddrLen = 0;
943 int protocolID = 0;
944 int singleRemotePort = 0;
945 CHAR portRange[TEL_AT_APPSTART_7_PORT_RANGE_STR_MAX_LEN + 1] = {0};
946 INT16 portRangeLen = 0;
947 CHAR DNN[TEL_AT_APPSTART_8_DNN_STR_MAX_LEN + 1] = {0};
948 INT16 DNNLen = 0;
949 int connectCap = 0;
950 CHAR FQDN[TEL_AT_APPSTART_10_FQDN_STR_MAX_LEN + 1] = {0};
951 INT16 FQDNLen = 0;
952 BOOL paraValid = FALSE;
953
954 AppInfo rcvAppInfo;
955
956
957 UNUSEDPARAM(op)
958 UNUSEDPARAM(command_name_p)
959 UNUSEDPARAM(parameter_values_p)
960 UNUSEDPARAM(num_parameters)
961 UNUSEDPARAM(info_text_p)
962 /*
963 * Put parser index into the variable
964 */
965 CiRequestHandle atHandle;
966 TelAtParserID sAtpIndex;
967
968 sAtpIndex = *(TelAtParserID *)arg_p;
969 atHandle = MAKE_AT_HANDLE( sAtpIndex );
970 *xid_p = atHandle;
971
972
973 /*
974 * process operation
975 */
976 switch(op)
977 {
978 case TEL_EXT_SET_CMD: /* AT*APPSTART= */
979 {
980 memset(&rcvAppInfo, 0, sizeof(rcvAppInfo));
981
982 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 )
983 {
984 if( getExtString( parameter_values_p, 1, (CHAR *)osId, MAX_LEN_OF_OS_ID, &osIdLen, NULL ) == TRUE )
985 {
986 if((parameter_values_p[1].is_default == TRUE) || !osIdLen)
987 rcvAppInfo.osIdPresent = FALSE;
988 else
989 {
990 rcvAppInfo.osIdPresent = TRUE;
991 memcpy(rcvAppInfo.osId, osId, osIdLen);
992 }
993
994 if( getExtString( parameter_values_p, 2, (CHAR *)appId, MAX_LEN_OF_OS_APP_ID, &appIdLen, NULL ) == TRUE )
995 {
996 if((parameter_values_p[2].is_default == TRUE) || !appIdLen)
997 rcvAppInfo.appIdPresent = FALSE;
998 else
999 {
1000 rcvAppInfo.appIdPresent = TRUE;
1001 memcpy(rcvAppInfo.appId, appId, appIdLen);
1002 }
1003 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 )
1004 {
1005 if((parameter_values_p[3].is_default == TRUE) || !ipv4AddrLen)
1006 rcvAppInfo.ipv4AddrPresent = FALSE;
1007 else
1008 {
1009 rcvAppInfo.ipv4AddrPresent = TRUE;
1010 memcpy(rcvAppInfo.ipv4Addr, ipv4Addr, ipv4AddrLen);
1011 }
1012 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 )
1013 {
1014 if((parameter_values_p[4].is_default == TRUE) || !ipv6AddrLen)
1015 rcvAppInfo.ipv6AddrPresent = FALSE;
1016 else
1017 {
1018 rcvAppInfo.ipv6AddrPresent = TRUE;
1019 memcpy(rcvAppInfo.ipv6Addr, ipv6Addr, ipv6AddrLen);
1020 }
1021 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 )
1022 {
1023 if(parameter_values_p[5].is_default == TRUE)
1024 rcvAppInfo.protocolIDPresent = FALSE;
1025 else
1026 {
1027 rcvAppInfo.protocolIDPresent = TRUE;
1028 rcvAppInfo.protocolID = protocolID;
1029 }
1030 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 )
1031 {
1032 if(parameter_values_p[6].is_default == TRUE)
1033 rcvAppInfo.singleRemotePortPresent = FALSE;
1034 else
1035 {
1036 rcvAppInfo.singleRemotePortPresent = TRUE;
1037 rcvAppInfo.singleRemotePort = singleRemotePort;
1038 }
1039 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 )
1040 {
1041 if((parameter_values_p[7].is_default == TRUE) || !portRangeLen)
1042 rcvAppInfo.portRangePresent = FALSE;
1043 else
1044 {
1045 rcvAppInfo.portRangePresent = TRUE;
1046 memcpy(rcvAppInfo.portRange, portRange, portRangeLen);
1047 }
1048 if ( getExtString(parameter_values_p, 8, DNN, TEL_AT_APPSTART_8_DNN_STR_MAX_LEN, &DNNLen, TEL_AT_APPSTART_8_DNN_STR_DEFAULT) == TRUE )
1049 {
1050 if((parameter_values_p[8].is_default == TRUE) || !DNNLen)
1051 rcvAppInfo.DNNPresent = FALSE;
1052 else
1053 {
1054 rcvAppInfo.DNNPresent = TRUE;
1055 memcpy(rcvAppInfo.DNN, DNN, DNNLen);
1056 }
1057 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 )
1058 {
1059 if(parameter_values_p[9].is_default == TRUE)
1060 rcvAppInfo.connectCapPresent = FALSE;
1061 else
1062 {
1063 rcvAppInfo.connectCapPresent = TRUE;
1064 rcvAppInfo.connectCap = connectCap;
1065 }
1066 if ( getExtString(parameter_values_p, 10, FQDN, TEL_AT_APPSTART_10_FQDN_STR_MAX_LEN, &FQDNLen, TEL_AT_APPSTART_10_FQDN_STR_DEFAULT) == TRUE )
1067 {
1068 if((parameter_values_p[10].is_default == TRUE) || !FQDNLen)
1069 rcvAppInfo.FQDNPresent = FALSE;
1070 else
1071 {
1072 rcvAppInfo.FQDNPresent = TRUE;
1073 memcpy(rcvAppInfo.FQDN, FQDN, FQDNLen);
1074 }
1075 paraValid = TRUE;
1076
1077 ursp_app_start(mode, &rcvAppInfo);
1078 }
1079 }
1080 }
1081 }
1082 }
1083 }
1084 }
1085 }
1086 }
1087 }
1088 }
1089
1090 if(paraValid)
1091 ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
1092 else
1093 ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
1094
1095 break;
1096 }
1097
1098 case TEL_EXT_TEST_CMD: /* AT*APPSTART=? */
1099 case TEL_EXT_GET_CMD: /* AT*APPSTART? */
1100 {
1101 ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
1102 break;
1103 }
1104
1105 default:
1106 ret = ATRESP( atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
1107 break;
1108 }
1109
1110 /* handle the return value */
1111 rc = HANDLE_RETURN_VALUE(ret);
1112 return(rc);
1113}
1114#endif
1115
1116/*******************************************************************
1117* FUNCTION: APLOG
1118*
1119* DESCRIPTION: Used to control the ap log
1120*
1121* PARAMETERS:
1122*
1123* RETURNS:
1124*
1125*******************************************************************/
1126utlReturnCode_T apLog( const utlAtParameterOp_T op,
1127 const char *command_name_p,
1128 const utlAtParameterValue_P2c parameter_values_p,
1129 const size_t num_parameters,
1130 const char *info_text_p,
1131 unsigned int *xid_p,
1132 void *arg_p)
1133{
1134 UNUSEDPARAM(command_name_p)
1135 UNUSEDPARAM(parameter_values_p)
1136 UNUSEDPARAM(num_parameters)
1137 UNUSEDPARAM(info_text_p)
1138
1139 TelAtParserID sAtpIndex;
1140 int log = 0, err = 0;
1141 unsigned char diagLogFlag = 0;
1142 char respBuf[64];
1143 sAtpIndex = *(TelAtParserID *)arg_p;
1144 *xid_p = MAKE_AT_HANDLE(sAtpIndex);
1145 CiReturnCode ret = CIRC_FAIL;
1146 RETURNCODE_T rc = INITIAL_RETURN_CODE;
1147
1148 memset(respBuf, '\0', sizeof(respBuf));
1149
1150 switch ( op )
1151 {
1152 case TEL_EXT_GET_CMD: /* AT+APLOG? */
1153 {
1154 err = get_diag_log_flag(&diagLogFlag);
1155 if (err == 0)
1156 {
1157 sprintf(respBuf, "+APLOG: %d", diagLogFlag);
1158 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, respBuf);
1159 }
1160 else
1161 {
1162 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
1163 }
1164 break;
1165 }
1166
1167 case TEL_EXT_SET_CMD: /* AT+APLOG= */
1168 {
1169 if ( getExtValue( parameter_values_p, 0, &log, 0, 255, 0) == TRUE )
1170 {
1171 err = set_diag_log_flag((unsigned char)log);
1172 if (err != 0)
1173 {
1174 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
1175 break;
1176 }
1177 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
1178 }
1179 else
1180 {
1181 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
1182 }
1183 break;
1184 }
1185
1186 default:
1187 {
1188 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
1189 break;
1190 }
1191 }
1192
1193 /* handle the return value */
1194 rc = HANDLE_RETURN_VALUE(ret);
1195
1196 return(rc);
1197}
1198
qs.xiong68079a32025-08-15 11:29:57 +0800[diff] [blame^]1199/*******************************************************************
1200* FUNCTION: diagMediaSwitch
1201*
1202* DESCRIPTION: Used to control the diag media
1203*
1204* PARAMETERS:
1205*
1206* RETURNS:
1207*
1208*******************************************************************/
1209utlReturnCode_T diagMediaSwitch( const utlAtParameterOp_T op,
1210 const char *command_name_p,
1211 const utlAtParameterValue_P2c parameter_values_p,
1212 const size_t num_parameters,
1213 const char *info_text_p,
1214 unsigned int *xid_p,
1215 void *arg_p)
1216{
1217 UNUSEDPARAM(command_name_p)
1218 UNUSEDPARAM(parameter_values_p)
1219 UNUSEDPARAM(num_parameters)
1220 UNUSEDPARAM(info_text_p)
1221
1222 TelAtParserID sAtpIndex;
1223 int save = 0, err = 0;
1224 CHAR diag_media[8] = {0};
1225 INT16 strLen = 0;
1226 CHAR returnStr[32] = {0};
1227 CHAR cmdStr[32] = {0};
1228 sAtpIndex = *(TelAtParserID *)arg_p;
1229 *xid_p = MAKE_AT_HANDLE(sAtpIndex);
1230 CiReturnCode ret = CIRC_FAIL;
1231 RETURNCODE_T rc = INITIAL_RETURN_CODE;
1232
1233 memset(diag_media, '\0', sizeof(diag_media));
1234
1235 switch ( op )
1236 {
1237 case TEL_EXT_SET_CMD: /* AT*DIAGSWITCH= */
1238 {
1239
1240 if( getExtString( parameter_values_p, 0, (CHAR *)diag_media, 8, &strLen, NULL ) == TRUE )
1241 {
1242 if ( getExtValue( parameter_values_p, 1, &save, 0, 1, 0) == TRUE )
1243 {
1244 ERRMSG(diagMediaSwitch001, "%s: diag_media=%s, save=%u\n", __FUNCTION__, diag_media, save);
1245 if (strLen > 0)
1246 {
1247 if (save > 0)
1248 {
1249 memset(returnStr, 0x00, sizeof(returnStr));
1250 memset(cmdStr, 0x00, sizeof(cmdStr));
1251 snprintf(cmdStr, sizeof(cmdStr), "/bin/diagcmd save %s", diag_media);
1252 err = executeShellCMD(cmdStr, returnStr);
1253 ERRMSG(diagMediaSwitch002, "%s: err=%d, returnStr=%s\n", __FUNCTION__, err, returnStr);
1254 }
1255
1256 memset(returnStr, 0x00, sizeof(returnStr));
1257 memset(cmdStr, 0x00, sizeof(cmdStr));
1258 snprintf(cmdStr, sizeof(cmdStr), "/bin/diagcmd switch %s", diag_media);
1259 err = executeShellCMD(cmdStr, returnStr);
1260 ERRMSG(diagMediaSwitch003, "%s: err=%d, returnStr=%s\n", __FUNCTION__, err, returnStr);
1261 }
1262
1263 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
1264 }
1265 }
1266 else
1267 {
1268 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
1269 }
1270 break;
1271 }
1272
1273 case TEL_EXT_GET_CMD: /* AT*DIAGSWITCH? */
1274 default:
1275 {
1276 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
1277 break;
1278 }
1279 }
1280
1281 /* handle the return value */
1282 rc = HANDLE_RETURN_VALUE(ret);
1283
1284 return(rc);
1285}
b.liue9582032025-04-17 19:18:16 +0800[diff] [blame]1286
1287/*******************************************************************
1288* FUNCTION: ciRdup
1289*
1290* DESCRIPTION: Used to control the RDUP flag
1291*
1292* PARAMETERS:
1293*
1294* RETURNS:
1295*
1296*******************************************************************/
1297utlReturnCode_T ciRdup( const utlAtParameterOp_T op,
1298 const char *command_name_p,
1299 const utlAtParameterValue_P2c parameter_values_p,
1300 const size_t num_parameters,
1301 const char *info_text_p,
1302 unsigned int *xid_p,
1303 void *arg_p)
1304{
1305 UNUSEDPARAM(command_name_p)
1306 UNUSEDPARAM(parameter_values_p)
1307 UNUSEDPARAM(num_parameters)
1308 UNUSEDPARAM(info_text_p)
1309
1310 TelAtParserID sAtpIndex;
1311 int rdup = 0, err = 0;
1312 CHAR returnStr[32] = {0};
1313 sAtpIndex = *(TelAtParserID *)arg_p;
1314 *xid_p = MAKE_AT_HANDLE(sAtpIndex);
1315 CiReturnCode ret = CIRC_FAIL;
1316 RETURNCODE_T rc = INITIAL_RETURN_CODE;
1317
1318 switch ( op )
1319 {
1320 case TEL_EXT_GET_CMD: /* AT+RDUP? */
1321 {
1322 break;
1323 }
1324
1325 case TEL_EXT_SET_CMD: /* AT+RDUP= */
1326 {
1327 if ( getExtValue( parameter_values_p, 0, &rdup, 0, 1, 0) == TRUE )
1328 {
1329 // ERRMSG(ciRdup000, "%s: rdup=%d\n", __FUNCTION__, rdup);
1330 if (rdup == 0)
1331 {
1332 memset(returnStr, 0x00, sizeof(returnStr));
1333 err = executeShellCMD("echo 0 > /proc/sys/kernel/rdup", returnStr);
1334 ERRMSG(ciRdup001, "%s: err=%d\n", __FUNCTION__, err);
1335 }
1336 else if (rdup == 1)
1337 {
1338 memset(returnStr, 0x00, sizeof(returnStr));
1339 err = executeShellCMD("echo 1 > /proc/sys/kernel/rdup", returnStr);
1340 ERRMSG(ciRdup002, "%s: err=%d\n", __FUNCTION__, err);
1341 }
1342 else
1343 {
1344 //nothing to be do
1345 }
1346 ret = ATRESP(*xid_p, ATCI_RESULT_CODE_OK, 0, NULL);
1347 }
1348 else
1349 {
1350 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL );
1351 }
1352 break;
1353 }
1354
1355 default:
1356 {
1357 ret = ATRESP( *xid_p, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL );
1358 break;
1359 }
1360 }
1361
1362 /* handle the return value */
1363 rc = HANDLE_RETURN_VALUE(ret);
1364
1365 return(rc);
1366}
1367
1368#ifdef GPS_SUPPORT
1369#include "gps.h"
1370#include "atcmdsvr_ubus.h"
1371
1372const struct blobmsg_policy gps_user_cb_policy[] = {
1373 [0] = {
1374 .name = "event",
1375 .type = BLOBMSG_TYPE_INT32,
1376 },
1377};
1378
1379const struct blobmsg_policy gps_state_resp_cb_policy[] = {
1380 [0] = {
1381 .name = "gps_state_resp",
1382 .type = BLOBMSG_TYPE_STRING,
1383 },
1384};
1385
1386static void gps_usr_callback_hdl(struct ubus_request *req, int type, struct blob_attr *msg)
1387{
1388 UNUSEDPARAM(type);
1389
1390 struct blob_attr *tb[1];
1391 struct blob_attr *cur;
1392 unsigned int event;
1393 UINT32 atHandle = *(int *)req->priv;
1394 int rc;
1395
1396 /*parsing blob to be accessed easily with tb array - parse "1" argument*/
1397 rc = blobmsg_parse(gps_user_cb_policy, 1, tb, blob_data(msg), blob_len(msg));
1398 if (rc < 0) {
1399 ERRMSG(gps_usr_callback_hdl0, "gps_usr_callback_hdl: blobmsg_parse fail\n");
1400 ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, CME_UNKNOWN, NULL);
1401 return;
1402 }
1403
1404 /*parse first parameter*/
1405 cur = tb[0];
1406 if (!cur) {
1407 ERRMSG(gps_usr_callback_hdl1, "gps_usr_callback_hdl: missing parameter\n");
1408 ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, CME_UNKNOWN, NULL);
1409 return;
1410 }
1411
1412 event = blobmsg_get_u32(cur);
1413 ERRMSG(gps_usr_callback_hdl2, "%s: event=%d",__func__, event);
1414
1415 switch(event)
1416 {
1417 case ASR_GPS_INITIAL_SUCCESS:
1418 case ASR_GPS_INITIALED:
1419 ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: start up success.\r\n");
1420 break;
1421
1422 case ASR_GPS_INITIAL_FAILED:
1423 ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: start up fail.\r\n");
1424 break;
1425
1426 case ASR_GPS_DOWNLOAD_SUCCESS:
1427 ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: AGPS download success.\r\n");
1428 break;
1429
1430 case ASR_GPS_DOWNLOAD_FAIL:
1431 ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: AGPS download fail.\r\n");
1432 break;
1433
1434 case ASR_GPS_SEND_DATA_SUCCESS:
1435 ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: AGPS send success.\r\n");
1436 break;
1437
1438 case ASR_GPS_SEND_DATA_FAIL:
1439 ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: AGPS send fail.\r\n");
1440 break;
1441
1442 case ASR_GPS_DEINIT_SUCCESS:
1443 ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: AGPS poweroff success.\r\n");
1444 break;
1445
1446 case ASR_GPS_DEINIT_FAIL:
1447 ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: AGPS poweroff fail.\r\n");
1448 break;
1449
1450 default:
1451 break;
1452 }
1453
1454 return;
1455}
1456
1457static void gps_state_response_callback(struct ubus_request *req, int type, struct blob_attr *msg)
1458{
1459 UNUSEDPARAM(type);
1460
1461 struct blob_attr *tb[1];
1462 struct blob_attr *cur;
1463 char *gps_state;
1464 UINT32 atHandle = *(int *)req->priv;
1465 int rc;
1466 char outString[128] = {0};
1467
1468 /*parsing blob to be accessed easily with tb array - parse "1" argument*/
1469 rc = blobmsg_parse(gps_state_resp_cb_policy, 1, tb, blob_data(msg), blob_len(msg));
1470 if (rc < 0) {
1471 ERRMSG(gps_state_response_callback0, "gps_state_response_callback: blobmsg_parse fail\n");
1472 ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, CME_UNKNOWN, NULL);
1473 return;
1474 }
1475
1476 /*parse first parameter*/
1477 cur = tb[0];
1478 if (!cur) {
1479 ERRMSG(gps_state_response_callback1, "gps_state_response_callback: missing parameter\n");
1480 ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, CME_UNKNOWN, NULL);
1481 return;
1482 }
1483
1484 gps_state = blobmsg_get_string(cur);
1485 ERRMSG(gps_state_response_callback12, "%s: gps_state=%s",__func__, gps_state);
1486 memset(outString, '\0', sizeof(outString));
1487 snprintf(outString, sizeof(outString), "+GPSST: %s\r\n", gps_state);
1488
1489 ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, outString);
1490
1491 return;
1492}
1493
1494RETURNCODE_T ciGPSInit(const utlAtParameterOp_T op,
1495 const char *command_name_p,
1496 const utlAtParameterValue_P2c parameter_values_p,
1497 const size_t num_parameters,
1498 const char *info_text_p,
1499 unsigned int *xid_p,
1500 void *arg_p)
1501{
1502 UNUSEDPARAM(command_name_p)
1503 UNUSEDPARAM(num_parameters)
1504 UNUSEDPARAM(info_text_p)
1505
1506 RETURNCODE_T rc = INITIAL_RETURN_CODE;
1507 CiReturnCode ret = CIRC_FAIL;
1508 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
1509 *xid_p = atHandle;
1510 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
1511
1512 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
1513
1514 /*
1515 ** Check the format of the request.
1516 */
1517 switch(op)
1518 {
1519 case TEL_EXT_GET_CMD: /* AT+GPSINIT? */
1520 {
1521 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
1522 break;
1523 }
1524
1525 case TEL_EXT_TEST_CMD: /* AT+GPSINIT=? */
1526 {
1527 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSINIT: (1,2)\r\n");
1528 break;
1529 }
1530
1531 case TEL_EXT_SET_CMD: /* AT+GPSINIT= */
1532 {
1533 INT32 gps_init_val;
1534 /* Extract the arguments starting with the functionality. */
1535 if (getExtValue(parameter_values_p, 0, (int *)&gps_init_val, 0, 1, 1) == TRUE)
1536 {
1537 struct blob_buf outBlob;
1538 memset(&outBlob, 0, sizeof(outBlob));
1539
1540 blob_buf_init(&outBlob, 0);
1541 blobmsg_add_u32(&outBlob, "gnss_init_param", (unsigned int)gps_init_val);
1542
1543 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)
1544 {
1545 ret = CIRC_SUCCESS;
1546 }
1547 else
1548 {
1549 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,NULL);
1550 }
1551 blob_buf_free(&outBlob);
1552 }
1553 else
1554 {
1555 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
1556 }
1557 break;
1558 }
1559
1560 case TEL_EXT_ACTION_CMD: /* AT+GPSINIT */
1561 default:
1562 {
1563 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
1564 break;
1565 }
1566 }
1567
1568 /* handle the return value */
1569 rc = HANDLE_RETURN_VALUE(ret);
1570 return(rc);
1571
1572}
1573
1574RETURNCODE_T ciGPSSleep(const utlAtParameterOp_T op,
1575 const char *command_name_p,
1576 const utlAtParameterValue_P2c parameter_values_p,
1577 const size_t num_parameters,
1578 const char *info_text_p,
1579 unsigned int *xid_p,
1580 void *arg_p)
1581{
1582 UNUSEDPARAM(command_name_p)
1583 UNUSEDPARAM(num_parameters)
1584 UNUSEDPARAM(info_text_p)
1585
1586 RETURNCODE_T rc = INITIAL_RETURN_CODE;
1587 CiReturnCode ret = CIRC_FAIL;
1588 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
1589 *xid_p = atHandle;
1590 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
1591
1592 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
1593
1594 /*
1595 ** Check the format of the request.
1596 */
1597 switch(op)
1598 {
1599 case TEL_EXT_GET_CMD: /* AT+GPSSLEEP? */
1600 {
1601 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
1602 break;
1603 }
1604
1605 case TEL_EXT_TEST_CMD: /* AT+GPSSLEEP=? */
1606 {
1607 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSSLEEP: (0,1)\r\n");
1608 break;
1609 }
1610
1611 case TEL_EXT_SET_CMD: /* AT+GPSSLEEP= */
1612 {
1613 INT32 gps_sleep_val;
1614 /* Extract the arguments starting with the functionality. */
1615 if (getExtValue(parameter_values_p, 0, (int *)&gps_sleep_val, 0, 1, 0) == TRUE)
1616 {
1617 struct blob_buf outBlob;
1618 memset(&outBlob, 0, sizeof(outBlob));
1619
1620 blob_buf_init(&outBlob, 0);
1621 blobmsg_add_u32(&outBlob, "gnss_sleep_param", (unsigned int)gps_sleep_val);
1622
1623 if (invoke_noreply_ril(origParserId, "gps", "gnss_sleep", outBlob.head) == UBUS_STATUS_OK)
1624 {
1625 ret = ATRESP(atHandle,ATCI_RESULT_CODE_OK,0,NULL);
1626 }
1627 else
1628 {
1629 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,NULL);
1630 }
1631 blob_buf_free(&outBlob);
1632 }
1633 else
1634 {
1635 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
1636 }
1637 break;
1638 }
1639
1640 case TEL_EXT_ACTION_CMD: /* AT+GPSSLEEP */
1641 default:
1642 {
1643 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
1644 break;
1645 }
1646 }
1647
1648 /* handle the return value */
1649 rc = HANDLE_RETURN_VALUE(ret);
1650 return(rc);
1651}
1652
1653RETURNCODE_T ciGPSPF(const utlAtParameterOp_T op,
1654 const char *command_name_p,
1655 const utlAtParameterValue_P2c parameter_values_p,
1656 const size_t num_parameters,
1657 const char *info_text_p,
1658 unsigned int *xid_p,
1659 void *arg_p)
1660{
1661 UNUSEDPARAM(command_name_p)
1662 UNUSEDPARAM(num_parameters)
1663 UNUSEDPARAM(info_text_p)
1664
1665 RETURNCODE_T rc = INITIAL_RETURN_CODE;
1666 CiReturnCode ret = CIRC_FAIL;
1667 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
1668 *xid_p = atHandle;
1669 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
1670
1671 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
1672
1673 /*
1674 ** Check the format of the request.
1675 */
1676 switch(op)
1677 {
1678 case TEL_EXT_ACTION_CMD: /* AT+GPSPF */
1679 {
1680 if (invoke_reply_data_cb_ril(origParserId, "gps", "gnss_deinit", NULL, (ubus_data_handler_t *)gps_usr_callback_hdl, &atHandle, 5000) == UBUS_STATUS_OK)
1681 {
1682 ret = CIRC_SUCCESS;
1683 }
1684 else
1685 {
1686 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,NULL);
1687 }
1688 break;
1689 }
1690
1691 default:
1692 {
1693 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
1694 break;
1695 }
1696 }
1697
1698 /* handle the return value */
1699 rc = HANDLE_RETURN_VALUE(ret);
1700 return(rc);
1701}
1702
1703RETURNCODE_T ciAGnssGet(const utlAtParameterOp_T op,
1704 const char *command_name_p,
1705 const utlAtParameterValue_P2c parameter_values_p,
1706 const size_t num_parameters,
1707 const char *info_text_p,
1708 unsigned int *xid_p,
1709 void *arg_p)
1710{
1711 UNUSEDPARAM(command_name_p)
1712 UNUSEDPARAM(num_parameters)
1713 UNUSEDPARAM(info_text_p)
1714
1715 RETURNCODE_T rc = INITIAL_RETURN_CODE;
1716 CiReturnCode ret = CIRC_FAIL;
1717 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
1718 *xid_p = atHandle;
1719 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
1720
1721 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
1722
1723 /*
1724 ** Check the format of the request.
1725 */
1726 switch(op)
1727 {
1728 case TEL_EXT_GET_CMD: /* AT+AGNSSGET? */
1729 {
1730 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
1731 break;
1732 }
1733
1734 case TEL_EXT_TEST_CMD: /* AT+AGNSSGET=? */
1735 {
1736 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+AGNSSGET: <supl_server_addr>\r\n");
1737 break;
1738 }
1739
1740 case TEL_EXT_SET_CMD: /* AT+AGNSSGET= */
1741 {
1742 #define SUPL_SERVER_ADDR_LEN 256
1743 char supl_server[SUPL_SERVER_ADDR_LEN];
1744 char lat[16], lon[16], acc[16];
1745 INT16 supl_server_len = 0, lat_len = 0, lon_len = 0, acc_len = 0;
1746 memset(supl_server, 0, SUPL_SERVER_ADDR_LEN);
1747 memset(lat, 0x00, 16);
1748 memset(lon, 0x00, 16);
1749 memset(acc, 0x00, 16);
1750 int alm_flag;
1751
1752 /* Extract the arguments starting with the functionality. */
1753 if (getExtString(parameter_values_p, 0, supl_server, SUPL_SERVER_ADDR_LEN, &supl_server_len, NULL) == TRUE)
1754 {
1755 if (getExtValue(parameter_values_p, 1, &alm_flag, 0, 3, 0) == TRUE)
1756 {
1757 if (getExtString(parameter_values_p, 2, lat, 16, &lat_len, NULL) == TRUE)
1758 {
1759 if (getExtString(parameter_values_p, 3, lon, 16, &lon_len, NULL) == TRUE)
1760 {
1761 if (getExtString(parameter_values_p, 4, acc, 16, &acc_len, NULL) == TRUE)
1762 {
1763 struct blob_buf outBlob;
1764 memset(&outBlob, 0, sizeof(outBlob));
1765
1766 blob_buf_init(&outBlob, 0);
1767 blobmsg_add_string(&outBlob, "server_name", supl_server);
1768 blobmsg_add_u32(&outBlob, "alam_flag", alm_flag);
1769 blobmsg_add_string(&outBlob, "lat", lat);
1770 blobmsg_add_string(&outBlob, "lon", lon);
1771 blobmsg_add_string(&outBlob, "acc", acc);
1772 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)
1773 {
1774 ret = CIRC_SUCCESS;
1775 }
1776 else
1777 {
1778 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,NULL);
1779 }
1780 blob_buf_free(&outBlob);
1781 }
1782 }
1783 }
1784 }
1785 else
1786 {
1787 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
1788 } }
1789 else
1790 {
1791 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
1792 }
1793
1794 break;
1795 }
1796
1797 case TEL_EXT_ACTION_CMD: /* AT+AGNSSGET */
1798 default:
1799 {
1800 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
1801 break;
1802 }
1803 }
1804
1805 /* handle the return value */
1806 rc = HANDLE_RETURN_VALUE(ret);
1807 return(rc);
1808}
1809
1810#ifdef AGPSTP_ENABLE
1811extern int SetAGPSConfig(char *host,unsigned short port, char *username, char *passwd ,int day, int force);
1812RETURNCODE_T ciAGnssCfg(const utlAtParameterOp_T op,
1813 const char *command_name_p,
1814 const utlAtParameterValue_P2c parameter_values_p,
1815 const size_t num_parameters,
1816 const char *info_text_p,
1817 unsigned int *xid_p,
1818 void *arg_p)
1819{
1820 UNUSEDPARAM(command_name_p)
1821 UNUSEDPARAM(num_parameters)
1822 UNUSEDPARAM(info_text_p)
1823
1824 RETURNCODE_T rc = INITIAL_RETURN_CODE;
1825 CiReturnCode ret = CIRC_FAIL;
1826 int i = 0;
1827 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
1828 *xid_p = atHandle;
1829
1830 DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
1831 /*
1832 ** Check the format of the request.
1833 */
1834 switch(op)
1835 {
1836 case TEL_EXT_GET_CMD: /* AT+AGNSSCFG? */
1837 {
1838 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
1839 break;
1840 }
1841
1842 case TEL_EXT_TEST_CMD: /* AT+AGNSSCFG=? */
1843 {
1844 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+AGNSSCFG: <server>,<port>,<usr>,<passwd>,<day>,<force>\r\n");
1845 break;
1846 }
1847
1848 case TEL_EXT_SET_CMD: /* AT+AGNSSCFG= */
1849 {
1850#define SUPL_SERVER_ADDR_LEN 256
1851#define MAX_DAY 365
1852 char supl_server[SUPL_SERVER_ADDR_LEN];
1853 INT16 supl_server_len;
1854 memset(supl_server, 0, SUPL_SERVER_ADDR_LEN);
1855 int port = 0;
1856 char username[16];
1857 char passwd[16];
1858 int day = 0;
1859 int force = 0;
1860 memset(username,0,sizeof(username));
1861 memset(passwd,0,sizeof(passwd));
1862 /* Extract the arguments starting with the functionality. */
1863 do {
1864 ret = getExtString(parameter_values_p, 0, supl_server,
1865 SUPL_SERVER_ADDR_LEN, &supl_server_len, NULL);
1866 if (ret != TRUE)
1867 break;
1868
1869 ret = getExtValue(parameter_values_p, 1, &port, 0, 65536, 0);
1870 if (ret != TRUE)
1871 break;
1872 supl_server_len = sizeof(username);
1873
1874 ret = getExtString(parameter_values_p, 2, username, 16,
1875 &supl_server_len, NULL);
1876 if (ret != TRUE)
1877 break;
1878
1879 supl_server_len = sizeof(passwd);
1880 ret = getExtString(parameter_values_p, 3, passwd, 16,
1881 &supl_server_len, NULL);
1882 if (ret != TRUE)
1883 break;
1884
1885 ret = getExtValue(parameter_values_p, 4, &day, 0, MAX_DAY, 0);
1886 if (ret != TRUE)
1887 break;
1888
1889 ret = getExtValue(parameter_values_p, 5, &force, 0, 1, 0);
1890 if (ret != TRUE)
1891 break;
1892 }while(0);
1893 if(ret != TRUE){
1894 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL);
1895 } else {
1896 if (SetAGPSConfig(supl_server, port, username, passwd, day, force) < 0) {
1897 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED, NULL);
1898 } else {
1899 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
1900 }
1901 }
1902 break;
1903 }
1904
1905 case TEL_EXT_ACTION_CMD: /* AT+AGNSSCFG */
1906 default:
1907 {
1908 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
1909 break;
1910 }
1911 }
1912
1913 /* handle the return value */
1914 rc = HANDLE_RETURN_VALUE(ret);
1915 return(rc);
1916}
1917#endif
1918
1919RETURNCODE_T ciAGnssSet(const utlAtParameterOp_T op,
1920 const char *command_name_p,
1921 const utlAtParameterValue_P2c parameter_values_p,
1922 const size_t num_parameters,
1923 const char *info_text_p,
1924 unsigned int *xid_p,
1925 void *arg_p)
1926{
1927 UNUSEDPARAM(command_name_p)
1928 UNUSEDPARAM(num_parameters)
1929 UNUSEDPARAM(info_text_p)
1930
1931 RETURNCODE_T rc = INITIAL_RETURN_CODE;
1932 CiReturnCode ret = CIRC_FAIL;
1933 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
1934 *xid_p = atHandle;
1935 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
1936
1937 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
1938
1939 /*
1940 ** Check the format of the request.
1941 */
1942 switch(op)
1943 {
1944 case TEL_EXT_ACTION_CMD: /* AT+AGNSSSET */
1945 {
1946 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)
1947 {
1948 ret = CIRC_SUCCESS;
1949 }
1950 else
1951 {
1952 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,NULL);
1953 }
1954 break;
1955 }
1956
1957 default:
1958 {
1959 break;
1960 }
1961 }
1962
1963 /* handle the return value */
1964 rc = HANDLE_RETURN_VALUE(ret);
1965 return(rc);
1966
1967}
1968
1969RETURNCODE_T ciGPSState(const utlAtParameterOp_T op,
1970 const char *command_name_p,
1971 const utlAtParameterValue_P2c parameter_values_p,
1972 const size_t num_parameters,
1973 const char *info_text_p,
1974 unsigned int *xid_p,
1975 void *arg_p)
1976{
1977 UNUSEDPARAM(command_name_p)
1978 UNUSEDPARAM(num_parameters)
1979 UNUSEDPARAM(info_text_p)
1980
1981 RETURNCODE_T rc = INITIAL_RETURN_CODE;
1982 CiReturnCode ret = CIRC_FAIL;
1983 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
1984 *xid_p = atHandle;
1985 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
1986
1987 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
1988
1989 /*
1990 ** Check the format of the request.
1991 */
1992 switch(op)
1993 {
1994 case TEL_EXT_ACTION_CMD: /* AT+GPSST */
1995 {
1996 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)
1997 {
1998 ret = CIRC_SUCCESS;
1999 }
2000 else
2001 {
2002 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,NULL);
2003 }
2004 break;
2005 }
2006
2007 default:
2008 {
2009 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
2010 break;
2011 }
2012 }
2013
2014 /* handle the return value */
2015 rc = HANDLE_RETURN_VALUE(ret);
2016 return(rc);
2017}
2018
2019RETURNCODE_T ciGPSSetting(const utlAtParameterOp_T op,
2020 const char *command_name_p,
2021 const utlAtParameterValue_P2c parameter_values_p,
2022 const size_t num_parameters,
2023 const char *info_text_p,
2024 unsigned int *xid_p,
2025 void *arg_p)
2026{
2027 UNUSEDPARAM(command_name_p)
2028 UNUSEDPARAM(num_parameters)
2029 UNUSEDPARAM(info_text_p)
2030
2031 RETURNCODE_T rc = INITIAL_RETURN_CODE;
2032 CiReturnCode ret = CIRC_FAIL;
2033 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
2034 *xid_p = atHandle;
2035 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
2036 char gps_str[128];
2037 INT16 gps_str_len;
2038 memset(gps_str, 0, 128);
2039
2040 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
2041
2042 /*
2043 ** Check the format of the request.
2044 */
2045 switch(op)
2046 {
2047 case TEL_EXT_GET_CMD: /* AT+GPSSETTING? */
2048 {
2049 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
2050 break;
2051 }
2052
2053 case TEL_EXT_TEST_CMD: /* AT+GPSSETTING=? */
2054 {
2055 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSSETTING: <string>\r\n");
2056 break;
2057 }
2058
2059 case TEL_EXT_SET_CMD: /* AT+GPSSETTING= */
2060 {
2061 /* Extract the arguments starting with the functionality. */
2062 if (getExtString(parameter_values_p, 0, gps_str, 128, &gps_str_len, NULL) == TRUE)
2063 {
2064 struct blob_buf outBlob;
2065 memset(&outBlob, 0, sizeof(outBlob));
2066
2067 blob_buf_init(&outBlob, 0);
2068 blobmsg_add_string(&outBlob, "gnss_setting_param", gps_str);
2069
2070 if (invoke_noreply_ril(origParserId, "gps", "gnss_setting", outBlob.head) == UBUS_STATUS_OK)
2071 {
2072 ret = ATRESP(atHandle,ATCI_RESULT_CODE_OK,0,NULL);
2073 }
2074 else
2075 {
2076 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_NOT_FOUND,NULL);
2077 }
2078 blob_buf_free(&outBlob);
2079 }
2080 else
2081 {
2082 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
2083 }
2084 break;
2085 }
2086
2087 case TEL_EXT_ACTION_CMD: /* AT+GPSSETTING */
2088 default:
2089 {
2090 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
2091 break;
2092 }
2093 }
2094
2095 /* handle the return value */
2096 rc = HANDLE_RETURN_VALUE(ret);
2097 return(rc);
2098}
2099
b.liu37ac3842025-05-26 21:22:12 +0800[diff] [blame]2100#else
2101#define MBTK_IND_START_FLAG 0xFF
2102#define MBTK_IND_END_FLAG 0xEE
2103#define SUPL_SERVER_ADDR_LEN 256
2104#define MBTK_CMD_RSP_LEN 256
2105#define GNSS_SOCK_PATH "/tmp/mbtk_gnss_sock"
2106
2107static int sock_listen_fd = -1;
2108static char cmd_rsp[MBTK_CMD_RSP_LEN] = {0};
2109
2110typedef enum {
2111 GNSS_CMD_INIT = 0,
2112 GNSS_CMD_DEINIT,
2113 GNSS_CMD_SETTING,
2114 GNSS_CMD_DL,
2115 GNSS_CMD_AGNSS_GET,
2116 GNSS_CMD_AGNSS_SET
2117} gnss_cmd_enum;
2118
2119typedef enum {
2120 GNSS_ERR_OK,
2121 GNSS_ERR_CLI_FULL,
2122 GNSS_ERR_UNKNOWN_HANDLE,
2123 GNSS_ERR_UNSUPPORT,
2124 GNSS_ERR_TIMEOUT,
2125 GNSS_ERR_ARG,
2126 GNSS_ERR_CHECKSUM,
2127 GNSS_ERR_SET_BUSY,
2128 GNSS_ERR_DL_FW,
2129 GNSS_ERR_OPEN_DEV,
2130 GNSS_ERR_FORMAT,
2131 GNSS_ERR_BUSY,
2132 GNSS_ERR_EPH_GET_FAIL,
2133 GNSS_ERR_EPH_INJECT_FAIL,
2134 GNSS_ERR_UNKNOWN
2135} gnss_err_enum;
2136
2137#if 1
2138#include <dlfcn.h>
2139
2140#define MBTK_LIB_PATH "/lib/libmbtk_lib.so"
2141
2142typedef unsigned char boolean; /* Boolean value type. */
2143// typedef unsigned char bool; /* Boolean value type. */
2144typedef unsigned long long uint64; /* Unsigned 64 bit value */
2145typedef unsigned long long uint64_t; /* Unsigned 64 bit value */
2146typedef unsigned int uint32; /* Unsigned 32 bit value */
2147typedef unsigned int uint32_t; /* Unsigned 32 bit value */
2148typedef unsigned short uint16; /* Unsigned 16 bit value */
2149typedef unsigned short uint16_t;
2150typedef unsigned char uint8; /* Unsigned 8 bit value */
2151typedef unsigned char uint8_t;
2152typedef signed long long int64; /* Signed 64 bit value */
2153typedef signed long long sint64; /* Signed 64 bit value */
2154typedef signed int int32; /* Signed 32 bit value */
2155typedef signed int sint32; /* Signed 32 bit value */
2156typedef signed short int16; /* Signed 16 bit value */
2157typedef signed short sint16; /* Signed 16 bit value */
2158typedef signed char int8; /* Signed 8 bit value */
2159typedef signed char sint8; /* Signed 8 bit value */
2160typedef unsigned char byte; /* byte type */
2161
2162typedef enum {
2163 MBTK_MODEM_BAND_AREA_ALL,
2164 MBTK_MODEM_BAND_AREA_CN,
2165 MBTK_MODEM_BAND_AREA_EU,
2166 MBTK_MODEM_BAND_AREA_SA
2167} mbtk_modem_band_area_enum;
2168
2169typedef enum {
2170 MBTK_REBOOT_FLAG_NORMAL = 0,
2171 MBTK_REBOOT_FLAG_DOWNLOAD
2172} mbtk_device_info_reboot_flag_enum;
2173
2174typedef enum {
2175 MBTK_DEVICE_INFO_ITEM_BASIC = 0,
2176 MBTK_DEVICE_INFO_ITEM_FOTA,
2177 MBTK_DEVICE_INFO_ITEM_MODEM,
2178 MBTK_DEVICE_INFO_ITEM_LOG,
2179
2180 MBTK_DEVICE_INFO_ITEM_NUM
2181} mbtk_device_info_item_enum;
2182
2183typedef struct {
2184 uint8 name[16];
2185 uint32 version; // Default : 0x01
2186 uint8 project[16]; // T108 / L508_X6
2187 uint8 project_cust[16]; // T108_C1 / L508_X6_C1 (Refer to: Custom_Model in blf file.)
2188 uint32 ab_support; // 1 for ab
2189 mbtk_device_info_reboot_flag_enum reboot_flag;
2190 uint8 revision_out[48]; // L508_X6v01.01b04.00
2191 uint8 revision_in[64];
2192 uint8 build_time[64];
2193} mbtk_device_info_basic_t;
2194
2195typedef struct {
2196 uint8 name[16];
2197 uint32 version; // Default : 0x01
2198 mbtk_modem_band_area_enum band_area;
2199 uint32 band_gsm;
2200 uint32 band_wcdma;
2201 uint32 band_tdlte;
2202 uint32 band_fddlte;
2203 uint32 band_lte_ext;
2204} mbtk_device_info_modem_t;
2205
2206static bool dev_info_inited = FALSE;
2207static mbtk_device_info_basic_t info_basic;
2208static mbtk_device_info_modem_t info_modem;
2209
2210typedef int (*mbtk_dev_info_read_func)(mbtk_device_info_item_enum, void *, int);
2211
2212static int dev_info_get()
2213{
2214 if(dev_info_inited) {
2215 return 0;
2216 }
2217 void *handle = dlopen(MBTK_LIB_PATH , RTLD_LAZY);
2218 if(handle == NULL)
2219 {
2220 DBGMSG(dev_info_get_S, "dlopen() %s fail : %d", MBTK_LIB_PATH, errno);
2221 return -1;
2222 }
2223
2224 mbtk_dev_info_read_func dev_info_read = (mbtk_dev_info_read_func)dlsym(handle, "mbtk_dev_info_read");
2225 if(dev_info_read == NULL)
2226 {
2227 DBGMSG(dev_info_read_S, "dlsym(mbtk_dev_info_read) fail : %d", errno);
2228 return -1;
2229 }
2230
2231 memset(&info_basic, 0, sizeof(mbtk_device_info_basic_t));
2232 memset(&info_modem, 0, sizeof(mbtk_device_info_modem_t));
2233
2234 // mbtk_dev_info_read()
2235 int result = dev_info_read(MBTK_DEVICE_INFO_ITEM_BASIC, &info_basic, sizeof(mbtk_device_info_basic_t));
2236 if(result) {
2237 DBGMSG(dev_info_read_S, "mbtk_dev_info_read(BASIC) fail.");
2238 return -1;
2239 }
2240
2241 result = dev_info_read(MBTK_DEVICE_INFO_ITEM_MODEM, &info_modem, sizeof(mbtk_device_info_modem_t));
2242 if(result) {
2243 DBGMSG(dev_info_read_S, "mbtk_dev_info_read(MODEM) fail.");
2244 return -1;
2245 }
2246
2247 dev_info_inited = TRUE;
2248 return 0;
2249}
2250
2251static char* band_area_2_str(mbtk_modem_band_area_enum band_area)
2252{
2253 switch(band_area) {
2254 case MBTK_MODEM_BAND_AREA_CN:
2255 return "CN";
2256 case MBTK_MODEM_BAND_AREA_EU:
2257 return "EU";
2258 case MBTK_MODEM_BAND_AREA_SA:
2259 return "SA";
2260 default:
2261 return "DEF";
2262 }
2263}
2264
2265#endif
2266
2267//buf: %cgnss_setting:%d %s%c
2268static int mbtk_gnss_info_parse(char *data, int len)
2269{
2270 if(data == NULL || len == 0 || len > MBTK_CMD_RSP_LEN)
2271 {
2272 ERRMSG(mbtk_gnss_parse_1,"[AT_MBTK_GNSS] param error.\n");
2273 return -1;
2274 }
2275
2276 data[len - 1] = 0x0;
2277 char *p = data + 1;
2278 int result = 0;
2279 char temp[MBTK_CMD_RSP_LEN] = {0};
2280
2281 memset(cmd_rsp, 0x0, MBTK_CMD_RSP_LEN);
2282 if(2 == sscanf(p, "gnss_setting:%d %s", &result, temp))
2283 {
2284 if(memcmp(temp, "NULL", 4))
2285 {
2286 memcpy(cmd_rsp, temp, strlen(temp));
2287 }
2288 }
2289 else
2290 {
2291 ERRMSG(mbtk_gnss_parse_2,"[AT_MBTK_GNSS] parse error.\n");
2292 return -1;
2293 }
2294
2295 return result;
2296}
2297
2298static CiReturnCode mbtk_gps_err(gnss_err_enum result, UINT32 atHandle)
2299{
2300 CiReturnCode ret = CIRC_FAIL;
2301 switch(result)
2302 {
2303 case GNSS_ERR_CLI_FULL:
2304 {
2305 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: client full.\r\n");
2306 break;
2307 }
2308 case GNSS_ERR_UNKNOWN_HANDLE:
2309 {
2310 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: unknown handle.\r\n");
2311 break;
2312 }
2313 case GNSS_ERR_UNSUPPORT:
2314 {
2315 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: unsupport.\r\n");
2316 break;
2317 }
2318 case GNSS_ERR_TIMEOUT:
2319 {
2320 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: timeout.\r\n");
2321 break;
2322 }
2323 case GNSS_ERR_ARG:
2324 {
2325 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: param error.\r\n");
2326 break;
2327 }
2328 case GNSS_ERR_CHECKSUM:
2329 {
2330 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: checksum error.\r\n");
2331 break;
2332 }
2333 case GNSS_ERR_SET_BUSY:
2334 {
2335 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: set busy.\r\n");
2336 break;
2337 }
2338 case GNSS_ERR_DL_FW:
2339 {
2340 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: download fail.\r\n");
2341 break;
2342 }
2343 case GNSS_ERR_OPEN_DEV:
2344 {
2345 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: open dev fail.\r\n");
2346 break;
2347 }
2348 case GNSS_ERR_FORMAT:
2349 {
2350 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: format error.\r\n");
2351 break;
2352 }
2353 case GNSS_ERR_BUSY:
2354 {
2355 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: busy.\r\n");
2356 break;
2357 }
2358 case GNSS_ERR_EPH_GET_FAIL:
2359 {
2360 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: eph ser get fail.\r\n");
2361 break;
2362 }
2363 case GNSS_ERR_EPH_INJECT_FAIL:
2364 {
2365 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: agps ser inject fail.\r\n");
2366 break;
2367 }
2368 case GNSS_ERR_UNKNOWN:
2369 default:
2370 {
2371 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: unknown error.\r\n");
2372 break;
2373 }
2374 }
2375
2376 return ret;
2377}
2378
2379static int mbtk_GPS_process(gnss_cmd_enum cmd, void *arg)
2380{
2381 if(sock_listen_fd < 0) {
2382 sock_listen_fd = socket(AF_LOCAL, SOCK_STREAM, 0);
2383 if(sock_listen_fd < 0)
2384 {
2385 ERRMSG(mbtk_GPS_process_0,"[AT_MBTK_GNSS] socket() fail[%d].\n", errno);
2386 return -1;
2387 }
2388
2389 struct sockaddr_un cli_addr;
2390 memset(&cli_addr, 0, sizeof(cli_addr));
2391 cli_addr.sun_family = AF_LOCAL;
2392 strcpy(cli_addr.sun_path, GNSS_SOCK_PATH);
2393 if(connect(sock_listen_fd, (struct sockaddr *)&cli_addr, sizeof(cli_addr)))
2394 {
2395 ERRMSG(mbtk_GPS_process_1,"[AT_MBTK_GNSS] connect() fail[%d].\n", errno);
2396 close(sock_listen_fd);
2397 sock_listen_fd = -1;
2398 return -1;
2399 }
2400 }
2401
2402 char buff[100] = {0};
2403 char *ptr = NULL;
2404 int len = 0;
2405 int ret_len = 0;
2406 if(cmd == GNSS_CMD_INIT) {
2407 if(arg) {
2408 sprintf(buff, "gnss_init:%d", *(int*)arg);
2409 } else {
2410 return -1;
2411 }
2412 } else if(cmd == GNSS_CMD_DEINIT) {
2413 sprintf(buff, "gnss_deinit");
2414 } else if(cmd == GNSS_CMD_SETTING) {
2415 sprintf(buff, "gnss_setting:%s", (char *)arg);
2416 } else if(cmd == GNSS_CMD_DL) {
2417 sprintf(buff, "gnss_dl:%s", (char *)arg);
2418 } else if(cmd == GNSS_CMD_AGNSS_GET) {
2419 sprintf(buff, "gnss_agnss_get:%s", (char *)arg);
2420 } else if(cmd == GNSS_CMD_AGNSS_SET) {
2421 sprintf(buff, "gnss_agnss_set");
2422 } else {
2423 printf("Unknown cmd.\n");
2424 return -1;
2425 }
2426
2427 ret_len = write(sock_listen_fd, buff, strlen(buff));
2428 if(ret_len < 0)
2429 {
2430 ERRMSG(mbtk_GPS_process_2,"[AT_MBTK_GNSS] write() fail[%d].\n", errno);
2431 return -1;
2432 }
2433
2434 while(1) {
2435 memset(buff, 0, sizeof(buff));
2436 len = read(sock_listen_fd, buff, sizeof(buff));
2437 if(len > 0) {
2438 //buf: %cgnss_init:%d%c
2439 ERRMSG(mbtk_GPS_process_3,"[AT_MBTK_GNSS] RSP : %s\n", buff);
2440 buff[len] = 0;
2441 ptr = buff + 1;
2442 if(cmd == GNSS_CMD_INIT) {
2443 if(memcmp(ptr, "gnss_init", 9) == 0) {
2444 return atoi(ptr + 10);
2445 } else {
2446 ERRMSG(mbtk_GPS_process_4,"[AT_MBTK_GNSS] gnss_init response error.\n");
2447 return -1;
2448 }
2449 } else if(cmd == GNSS_CMD_DEINIT) {
2450 if(memcmp(ptr, "gnss_deinit", 11) == 0) {
2451 return atoi(ptr + 12);
2452 } else {
2453 ERRMSG(mbtk_GPS_process_5,"[AT_MBTK_GNSS] gnss_deinit response error.\n");
2454 return -1;
2455 }
2456 } else if(cmd == GNSS_CMD_SETTING) {
2457 if(memcmp(ptr, "gnss_setting", 12) == 0) { //buf: %cgnss_setting:%d %s%c
2458 return mbtk_gnss_info_parse(buff, len);
2459 } else {
2460 ERRMSG(mbtk_GPS_process_6,"[AT_MBTK_GNSS] gnss_setting response error.\n");
2461 return -1;
2462 }
2463 } else if(cmd == GNSS_CMD_DL) {
2464 if(memcmp(ptr, "gnss_dl", 7) == 0) {
2465 return atoi(ptr + 8);
2466 } else {
2467 ERRMSG(mbtk_GPS_process_7,"[AT_MBTK_GNSS] gnss_dl response error.\n");
2468 return -1;
2469 }
2470 } else if(cmd == GNSS_CMD_AGNSS_GET) {
2471 if(memcmp(ptr, "gnss_agnss_get", 14) == 0) {
2472 return atoi(ptr + 15);
2473 } else {
2474 ERRMSG(mbtk_GPS_process_8,"[AT_MBTK_GNSS] gnss_dl response error.\n");
2475 return -1;
2476 }
2477 } else if(cmd == GNSS_CMD_AGNSS_SET) {
2478 if(memcmp(ptr, "gnss_agnss_set", 14) == 0) {
2479 return atoi(ptr + 15);
2480 } else {
2481 ERRMSG(mbtk_GPS_process_9,"[AT_MBTK_GNSS] gnss_dl response error.\n");
2482 return -1;
2483 }
2484 } else {
2485 ERRMSG(mbtk_GPS_process_10,"[AT_MBTK_GNSS] Unknown response.\n");
2486 return -1;
2487 }
2488 } else if(len == 0) {
2489 ERRMSG(mbtk_GPS_process_11,"[AT_MBTK_GNSS] RSP is null.\n");
2490 return -1;
2491 } else {
2492 ERRMSG(mbtk_GPS_process_12,"[AT_MBTK_GNSS] read = %d:errno = %d\n", len, errno);
2493 }
2494 }
2495}
2496
2497RETURNCODE_T mbtk_GPSInit(const utlAtParameterOp_T op,
2498 const char *command_name_p,
2499 const utlAtParameterValue_P2c parameter_values_p,
2500 const size_t num_parameters,
2501 const char *info_text_p,
2502 unsigned int *xid_p,
2503 void *arg_p)
2504{
2505 UNUSEDPARAM(command_name_p)
2506 UNUSEDPARAM(num_parameters)
2507 UNUSEDPARAM(info_text_p)
2508
2509 RETURNCODE_T rc = INITIAL_RETURN_CODE;
2510 CiReturnCode ret = CIRC_FAIL;
2511 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
2512 *xid_p = atHandle;
2513 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
2514
2515 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
2516
2517 /*
2518 ** Check the format of the request.
2519 */
2520 switch(op)
2521 {
2522 case TEL_EXT_TEST_CMD: /* AT+GPSINIT=? */
2523 {
2524 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSINIT: (0-15)\r\n");
2525 break;
2526 }
2527 case TEL_EXT_SET_CMD: /* AT+GPSINIT= */
2528 {
2529 INT32 gps_init_val;
2530 //0-close 1-uart1 2-USB_NAME 4-USB_AT 8-tty_gnss_name
2531 if (getExtValue(parameter_values_p, 0, (int *)&gps_init_val, 0, 15, 0) == TRUE)
2532 {
2533 int result = 0;
2534 result = mbtk_GPS_process(GNSS_CMD_INIT, &gps_init_val);
2535 if (result < 0)
2536 {
2537 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: init fail.\r\n");
2538 }
2539 else if((gnss_err_enum)result == GNSS_ERR_OK)
2540 {
2541 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: init success.\r\n");
2542 }
2543 else
2544 {
2545 ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
2546 }
2547 }
2548 else
2549 {
2550 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
2551 }
2552 break;
2553 }
2554 case TEL_EXT_GET_CMD: /* AT+GPSINIT? */
2555 case TEL_EXT_ACTION_CMD: /* AT+GPSINIT */
2556 default:
2557 {
2558 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
2559 break;
2560 }
2561 }
2562
2563 /* handle the return value */
2564 rc = HANDLE_RETURN_VALUE(ret);
2565 return(rc);
2566
2567}
2568
2569RETURNCODE_T mbtk_GPSDeInit(const utlAtParameterOp_T op,
2570 const char *command_name_p,
2571 const utlAtParameterValue_P2c parameter_values_p,
2572 const size_t num_parameters,
2573 const char *info_text_p,
2574 unsigned int *xid_p,
2575 void *arg_p)
2576{
2577 UNUSEDPARAM(command_name_p)
2578 UNUSEDPARAM(num_parameters)
2579 UNUSEDPARAM(info_text_p)
2580
2581 RETURNCODE_T rc = INITIAL_RETURN_CODE;
2582 CiReturnCode ret = CIRC_FAIL;
2583 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
2584 *xid_p = atHandle;
2585 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
2586
2587 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
2588
2589 /*
2590 ** Check the format of the request.
2591 */
2592 switch(op)
2593 {
2594 case TEL_EXT_ACTION_CMD: /* AT+GPSDEINIT */
2595 {
2596 int result = 0;
2597 result = mbtk_GPS_process(GNSS_CMD_DEINIT, NULL);
2598 if (result < 0)
2599 {
2600 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: deinit fail.\r\n");
2601 }
2602 else if((gnss_err_enum)result == GNSS_ERR_OK)
2603 {
2604 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: deinit success.\r\n");
2605 }
2606 else
2607 {
2608 ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
2609 }
2610 break;
2611 }
2612 case TEL_EXT_TEST_CMD: /* AT+GPSDEINIT=? */
2613 case TEL_EXT_GET_CMD: /* AT+GPSDEINIT? */
2614 case TEL_EXT_SET_CMD: /* AT+GPSDEINIT= */
2615 default:
2616 {
2617 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
2618 break;
2619 }
2620 }
2621
2622 /* handle the return value */
2623 rc = HANDLE_RETURN_VALUE(ret);
2624 return(rc);
2625}
2626
2627RETURNCODE_T mbtk_GPSSleep(const utlAtParameterOp_T op,
2628 const char *command_name_p,
2629 const utlAtParameterValue_P2c parameter_values_p,
2630 const size_t num_parameters,
2631 const char *info_text_p,
2632 unsigned int *xid_p,
2633 void *arg_p)
2634{
2635 UNUSEDPARAM(command_name_p)
2636 UNUSEDPARAM(num_parameters)
2637 UNUSEDPARAM(info_text_p)
2638
2639 RETURNCODE_T rc = INITIAL_RETURN_CODE;
2640 CiReturnCode ret = CIRC_FAIL;
2641 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
2642 *xid_p = atHandle;
2643 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
2644
2645 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
2646
2647 /*
2648 ** Check the format of the request.
2649 */
2650 switch(op)
2651 {
2652 case TEL_EXT_TEST_CMD: /* AT+GPSSLEEP=? */
2653 {
2654 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSSLEEP: (0,1)\r\n");
2655 break;
2656 }
2657
2658 case TEL_EXT_SET_CMD: /* AT+GPSSLEEP= */
2659 {
2660 INT32 gps_sleep_val;
2661 /* Extract the arguments starting with the functionality. */
2662 if (getExtValue(parameter_values_p, 0, (int *)&gps_sleep_val, 0, 1, 0) == TRUE)
2663 {
2664 ret = mbtk_gps_err(GNSS_ERR_UNSUPPORT, atHandle);
2665 }
2666 else
2667 {
2668 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
2669 }
2670 break;
2671 }
2672 case TEL_EXT_GET_CMD: /* AT+GPSSLEEP? */
2673 case TEL_EXT_ACTION_CMD: /* AT+GPSSLEEP */
2674 default:
2675 {
2676 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
2677 break;
2678 }
2679 }
2680
2681 /* handle the return value */
2682 rc = HANDLE_RETURN_VALUE(ret);
2683 return(rc);
2684}
2685
2686RETURNCODE_T mbtk_AGnssGet(const utlAtParameterOp_T op,
2687 const char *command_name_p,
2688 const utlAtParameterValue_P2c parameter_values_p,
2689 const size_t num_parameters,
2690 const char *info_text_p,
2691 unsigned int *xid_p,
2692 void *arg_p)
2693{
2694 UNUSEDPARAM(command_name_p)
2695 UNUSEDPARAM(num_parameters)
2696 UNUSEDPARAM(info_text_p)
2697
2698 RETURNCODE_T rc = INITIAL_RETURN_CODE;
2699 CiReturnCode ret = CIRC_FAIL;
2700 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
2701 *xid_p = atHandle;
2702 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
2703
2704 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
2705
2706 /*
2707 ** Check the format of the request.
2708 */
2709 switch(op)
2710 {
2711 case TEL_EXT_TEST_CMD: /* AT+AGNSSGET=? */
2712 {
2713 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+AGNSSGET: <eph_type>, <alam_flag>\r\n");
2714 break;
2715 }
2716 case TEL_EXT_SET_CMD: /* AT+AGNSSGET= */
2717 {
2718 int eph_type = 0;
2719 int alm_flag = 0;
2720 char param[128] = {0};
2721
2722 /* Extract the arguments starting with the functionality. */
2723 if (getExtValue(parameter_values_p, 0, &eph_type, 0, 6, 0) == TRUE)
2724 {
2725 if (getExtValue(parameter_values_p, 1, &alm_flag, 0, 1, 0) == TRUE)
2726 {
2727 int result = 0;
2728 snprintf(param, 128, "%d,%d", eph_type, alm_flag);
2729 result = mbtk_GPS_process(GNSS_CMD_AGNSS_GET, param);
2730 if (result < 0)
2731 {
2732 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: agps get eph fail.\r\n");
2733 }
2734 else if((gnss_err_enum)result == GNSS_ERR_OK)
2735 {
2736 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: agps get eph success.\r\n");
2737 }
2738 else
2739 {
2740 ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
2741 }
2742 }
2743 else
2744 {
2745 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
2746 }
2747 }
2748 else
2749 {
2750 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
2751 }
2752
2753
2754 break;
2755 }
2756 case TEL_EXT_GET_CMD: /* AT+AGNSSGET? */
2757 case TEL_EXT_ACTION_CMD: /* AT+AGNSSGET */
2758 default:
2759 {
2760 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
2761 break;
2762 }
2763 }
2764
2765 /* handle the return value */
2766 rc = HANDLE_RETURN_VALUE(ret);
2767 return(rc);
2768}
2769
2770RETURNCODE_T mbtk_AGnssCfg(const utlAtParameterOp_T op,
2771 const char *command_name_p,
2772 const utlAtParameterValue_P2c parameter_values_p,
2773 const size_t num_parameters,
2774 const char *info_text_p,
2775 unsigned int *xid_p,
2776 void *arg_p)
2777{
2778 UNUSEDPARAM(command_name_p)
2779 UNUSEDPARAM(num_parameters)
2780 UNUSEDPARAM(info_text_p)
2781
2782 RETURNCODE_T rc = INITIAL_RETURN_CODE;
2783 CiReturnCode ret = CIRC_FAIL;
2784 int i = 0;
2785 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
2786 *xid_p = atHandle;
2787
2788 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
2789 /*
2790 ** Check the format of the request.
2791 */
2792 switch(op)
2793 {
2794 case TEL_EXT_TEST_CMD: /* AT+AGNSSCFG=? */
2795 {
2796 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+AGNSSCFG: <server>,<port>,<usr>,<passwd>,<day>,<force>\r\n");
2797 break;
2798 }
2799 case TEL_EXT_GET_CMD: /* AT+AGNSSCFG? */
2800 case TEL_EXT_SET_CMD: /* AT+AGNSSCFG= */
2801 case TEL_EXT_ACTION_CMD: /* AT+AGNSSCFG */
2802 default:
2803 {
2804 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
2805 break;
2806 }
2807 }
2808
2809 /* handle the return value */
2810 rc = HANDLE_RETURN_VALUE(ret);
2811 return(rc);
2812}
2813
2814RETURNCODE_T mbtk_AGnssSet(const utlAtParameterOp_T op,
2815 const char *command_name_p,
2816 const utlAtParameterValue_P2c parameter_values_p,
2817 const size_t num_parameters,
2818 const char *info_text_p,
2819 unsigned int *xid_p,
2820 void *arg_p)
2821{
2822 UNUSEDPARAM(command_name_p)
2823 UNUSEDPARAM(num_parameters)
2824 UNUSEDPARAM(info_text_p)
2825
2826 RETURNCODE_T rc = INITIAL_RETURN_CODE;
2827 CiReturnCode ret = CIRC_FAIL;
2828 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
2829 *xid_p = atHandle;
2830 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
2831
2832 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
2833
2834 /*
2835 ** Check the format of the request.
2836 */
2837 switch(op)
2838 {
2839 case TEL_EXT_ACTION_CMD: /* AT+AGNSSSET */
2840 {
2841 int result = 0;
2842 result = mbtk_GPS_process(GNSS_CMD_AGNSS_SET, NULL);
2843 if (result < 0)
2844 {
2845 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: agps inject fail.\r\n");
2846 }
2847 else if((gnss_err_enum)result == GNSS_ERR_OK)
2848 {
2849 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: agps inject success.\r\n");
2850 }
2851 else
2852 {
2853 ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
2854 }
2855 break;
2856 }
2857 case TEL_EXT_TEST_CMD: /* AT+AGNSSSET=? */
2858 case TEL_EXT_GET_CMD: /* AT+AGNSSSET? */
2859 case TEL_EXT_SET_CMD: /* AT+AGNSSSET= */
2860 default:
2861 {
2862 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
2863 break;
2864 }
2865 }
2866
2867 /* handle the return value */
2868 rc = HANDLE_RETURN_VALUE(ret);
2869 return(rc);
2870
2871}
2872
2873RETURNCODE_T mbtk_GPSState(const utlAtParameterOp_T op,
2874 const char *command_name_p,
2875 const utlAtParameterValue_P2c parameter_values_p,
2876 const size_t num_parameters,
2877 const char *info_text_p,
2878 unsigned int *xid_p,
2879 void *arg_p)
2880{
2881 UNUSEDPARAM(command_name_p)
2882 UNUSEDPARAM(num_parameters)
2883 UNUSEDPARAM(info_text_p)
2884
2885 RETURNCODE_T rc = INITIAL_RETURN_CODE;
2886 CiReturnCode ret = CIRC_FAIL;
2887 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
2888 *xid_p = atHandle;
2889 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
2890
2891 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
2892
2893 /*
2894 ** Check the format of the request.
2895 */
2896 switch(op)
2897 {
2898 case TEL_EXT_ACTION_CMD: /* AT+GPSST */
2899 {
2900 ret = mbtk_gps_err(GNSS_ERR_UNSUPPORT, atHandle);
2901 break;
2902 }
2903 case TEL_EXT_TEST_CMD: /* AT+AGNSSCFG=? */
2904 case TEL_EXT_GET_CMD: /* AT+AGNSSCFG? */
2905 case TEL_EXT_SET_CMD: /* AT+AGNSSCFG= */
2906 default:
2907 {
2908 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
2909 break;
2910 }
2911 }
2912
2913 /* handle the return value */
2914 rc = HANDLE_RETURN_VALUE(ret);
2915 return(rc);
2916}
2917
2918
2919RETURNCODE_T mbtk_GPSSetting(const utlAtParameterOp_T op,
2920 const char *command_name_p,
2921 const utlAtParameterValue_P2c parameter_values_p,
2922 const size_t num_parameters,
2923 const char *info_text_p,
2924 unsigned int *xid_p,
2925 void *arg_p)
2926{
2927 UNUSEDPARAM(command_name_p)
2928 UNUSEDPARAM(num_parameters)
2929 UNUSEDPARAM(info_text_p)
2930
2931 RETURNCODE_T rc = INITIAL_RETURN_CODE;
2932 CiReturnCode ret = CIRC_FAIL;
2933 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
2934 *xid_p = atHandle;
2935 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
2936 char gps_str[128];
2937 INT16 gps_str_len;
2938 memset(gps_str, 0, 128);
2939
2940 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
2941
2942 /*
2943 ** Check the format of the request.
2944 */
2945 switch(op)
2946 {
2947 case TEL_EXT_TEST_CMD: /* AT+GPSSETTING=? */
2948 {
2949 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSSETTING: <string>\r\n");
2950 break;
2951 }
2952 case TEL_EXT_SET_CMD: /* AT+GPSSETTING= */
2953 {
2954 /* Extract the arguments starting with the functionality. */
2955 if (getExtString(parameter_values_p, 0, gps_str, 127, &gps_str_len, NULL) == TRUE)
2956 {
2957 int result = 0;
2958 result = mbtk_GPS_process(GNSS_CMD_SETTING, gps_str);
2959 if (result < 0)
2960 {
2961 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: setting fail.\r\n");
2962 }
2963 else if((gnss_err_enum)result == GNSS_ERR_OK)
2964 {
2965 char temp[512] = {0};
2966 if(strlen(cmd_rsp))
2967 {
2968 snprintf(temp, 512, "+GPS INFO: %s\r\n", cmd_rsp);
2969 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, temp);
2970 }
2971 else
2972 {
2973 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: setting success.\r\n");
2974 }
2975 }
2976 else
2977 {
2978 ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
2979 }
2980 }
2981 else
2982 {
2983 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
2984 }
2985 break;
2986 }
2987 case TEL_EXT_GET_CMD: /* AT+GPSSETTING? */
2988 case TEL_EXT_ACTION_CMD: /* AT+GPSSETTING */
2989 default:
2990 {
2991 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
2992 break;
2993 }
2994 }
2995
2996 /* handle the return value */
2997 rc = HANDLE_RETURN_VALUE(ret);
2998 return(rc);
2999}
3000
3001RETURNCODE_T mbtk_GPSFwdl(const utlAtParameterOp_T op,
3002 const char *command_name_p,
3003 const utlAtParameterValue_P2c parameter_values_p,
3004 const size_t num_parameters,
3005 const char *info_text_p,
3006 unsigned int *xid_p,
3007 void *arg_p)
3008{
3009 UNUSEDPARAM(command_name_p)
3010 UNUSEDPARAM(num_parameters)
3011 UNUSEDPARAM(info_text_p)
3012
3013 RETURNCODE_T rc = INITIAL_RETURN_CODE;
3014 CiReturnCode ret = CIRC_FAIL;
3015 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
3016 *xid_p = atHandle;
3017 TelAtParserID origParserId = *(TelAtParserID *)arg_p;
3018 char gps_str[128];
3019 INT16 gps_str_len;
3020 memset(gps_str, 0, 128);
3021
3022 int band = -1;
3023 char* bd = "gp_bd_ga";
3024 char* gl = "gp_gl_ga";
3025 /*
3026 ** Check the format of the request.
3027 */
3028 if(InProduction_Mode() == 0)
3029 {
3030 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: fwdl mode fail.\r\n");
3031 rc = HANDLE_RETURN_VALUE(ret);
3032 return(rc);
3033 }
3034
3035 switch(op)
3036 {
3037 case TEL_EXT_TEST_CMD: /* AT+GPSFWDL=? */
3038 {
3039 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, (char *)"+GPSFWDL: <string>\r\n");
3040 break;
3041 }
3042 case TEL_EXT_ACTION_CMD: /* AT+GPSFWDL */
3043 {
3044 if(!dev_info_get())
3045 {
3046 //Default bd
3047 band = info_modem.band_area;
3048 if(band == MBTK_MODEM_BAND_AREA_EU)
3049 strncpy(gps_str, gl, strlen(gl));
3050 else
3051 strncpy(gps_str, bd, strlen(bd));
3052 }
3053 //ATRESP(atHandle, ATCI_RESULT_CODE_NULL, 0, gps_str);
3054 if (band != -1)
3055 {
3056 int result = 0;
3057 result = mbtk_GPS_process(GNSS_CMD_DL, gps_str);
3058 if (result < 0)
3059 {
3060 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: fwdl fail.\r\n");
3061 }
3062 else if((gnss_err_enum)result == GNSS_ERR_OK)
3063 {
3064 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: fwdl success.\r\n");
3065 }
3066 else
3067 {
3068 ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
3069 }
3070 }
3071 else
3072 {
3073 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
3074 }
3075 break;
3076 }
3077 case TEL_EXT_SET_CMD: /* AT+GPSFWDL= */
3078 {
3079 /* Extract the arguments starting with the functionality. */
3080 if (getExtString(parameter_values_p, 0, gps_str, 127, &gps_str_len, NULL) == TRUE)
3081 {
3082 int result = 0;
3083 result = mbtk_GPS_process(GNSS_CMD_DL, gps_str);
3084 if (result < 0)
3085 {
3086 ret = ATRESP(atHandle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: fwdl fail.\r\n");
3087 }
3088 else if((gnss_err_enum)result == GNSS_ERR_OK)
3089 {
3090 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, "+GPS: fwdl success.\r\n");
3091 }
3092 else
3093 {
3094 ret = mbtk_gps_err((gnss_err_enum)result, atHandle);
3095 }
3096 }
3097 else
3098 {
3099 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
3100 }
3101 break;
3102 }
3103 case TEL_EXT_GET_CMD: /* AT+GPSFWDL? */
3104 default:
3105 {
3106 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
3107 break;
3108 }
3109 }
3110
3111 /* handle the return value */
3112 rc = HANDLE_RETURN_VALUE(ret);
3113 return(rc);
3114}
3115
b.liue9582032025-04-17 19:18:16 +0800[diff] [blame]3116#endif
3117
3118RETURNCODE_T ciCMTLRA(const utlAtParameterOp_T op,
3119 const char *command_name_p,
3120 const utlAtParameterValue_P2c parameter_values_p,
3121 const size_t num_parameters,
3122 const char *info_text_p,
3123 unsigned int *xid_p,
3124 void *arg_p)
3125{
3126 UNUSEDPARAM(command_name_p)
3127 UNUSEDPARAM(num_parameters)
3128 UNUSEDPARAM(info_text_p)
3129
3130 RETURNCODE_T rc = INITIAL_RETURN_CODE;
3131 CiReturnCode ret = CIRC_FAIL;
3132 UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p);
3133 TelAtParserID sAtpIndex = *(TelAtParserID *)arg_p;
3134 int allow = 0;
3135 int id = 0;
3136 UINT8 *pAllow = NULL;
3137 UINT8 *pHandleID = NULL;
3138 char rspBuf[40] = {0};
3139 UINT32 IndHandler = IND_REQ_HANDLE;
3140
3141 *xid_p = atHandle;
3142
3143 if (!GET_SIM1_FLAG(atHandle)) {
3144 pAllow = &gCmtlrAllow[sAtpIndex];
3145 pHandleID = &gCmtlrHandleID[sAtpIndex];
3146 IndHandler = IND_REQ_HANDLE;
3147 } else {
3148 pAllow = &gCmtlrAllow[sAtpIndex];
3149 pHandleID = &gCmtlrHandleID[sAtpIndex];
3150 IndHandler = IND_REQ_HANDLE_1;
3151 }
3152
3153 //DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle);
3154
3155 /*
3156 ** Check the format of the request.
3157 */
3158 switch(op)
3159 {
3160 case TEL_EXT_GET_CMD: /* AT+CMTLRA? */
3161 {
3162 snprintf(rspBuf, sizeof(rspBuf), "+CMTLRA: %d,%d", *pAllow, *pHandleID);
3163 ret = ATRESP(atHandle,ATCI_RESULT_CODE_OK,0,rspBuf);
3164 break;
3165 }
3166
3167 case TEL_EXT_SET_CMD: /* AT+CMTLRA= */
3168 {
3169 if (getExtValue(parameter_values_p, 0, &allow, 0, 1, 0) == TRUE)
3170 {
3171 if (getExtValue(parameter_values_p, 1, &id, 0, 255, 0) == TRUE)
3172 {
3173 *pAllow = allow;
3174 *pHandleID = id;
3175 snprintf(rspBuf, sizeof(rspBuf), "+CMTLRA: %d,%d", *pAllow, *pHandleID);
3176 ATRESP(IndHandler,0,0,rspBuf);
3177 ret = ATRESP(atHandle, ATCI_RESULT_CODE_OK, 0, NULL);
3178 }
3179 else
3180 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
3181 }
3182 else
3183 ret = ATRESP(atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_INVALID_PARAM, NULL);
3184
3185 break;
3186 }
3187
3188 default:
3189 {
3190 ret = ATRESP(atHandle,ATCI_RESULT_CODE_CME_ERROR,CME_OPERATION_NOT_SUPPORTED,NULL);
3191 break;
3192 }
3193 }
3194
3195 /* handle the return value */
3196 rc = HANDLE_RETURN_VALUE(ret);
3197 return(rc);
3198}
3199