FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/ati_mm.c @ 0:75a11d740a02

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 09 Jun 2016 00:02:41 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:75a11d740a02
1 /*
2 +-----------------------------------------------------------------------------
3 | Project : GSM-F&D (8411)
4 | Modul : ATI
5 +-----------------------------------------------------------------------------
6 | Copyright 2002 Texas Instruments Berlin, AG
7 | All rights reserved.
8 |
9 | This file is confidential and a trade secret of Texas
10 | Instruments Berlin, AG
11 | The receipt of or possession of this file does not convey
12 | any rights to reproduce or disclose its contents or to
13 | manufacture, use, or sell anything it may describe, in
14 | whole, or in part, without the specific written consent of
15 | Texas Instruments Berlin, AG.
16 +-----------------------------------------------------------------------------
17 | Purpose : AT Command Interpreter: Mobility Management related functions.
18 +-----------------------------------------------------------------------------
19 */
20
21 #ifndef ATI_MM_C
22 #define ATI_MM_C
23
24 #include "config.h"
25 #include "fixedconf.h"
26 #include "condat-features.h"
27 #include "aci_conf.h"
28
29 #undef DUMMY_ATI_STRINGS
30
31 #include "aci_all.h"
32
33 #include "aci_lst.h"
34 #include "aci_cmh.h"
35 #include "ati_cmd.h"
36 #include "aci_io.h"
37 #include "aci_cmd.h"
38 #include "l4_tim.h"
39
40 #include "aci_mem.h"
41 #include "aci_prs.h"
42
43 #include "ati_int.h"
44
45 #ifdef UART
46 #include "dti.h"
47 #include "dti_conn_mng.h"
48 #endif
49
50 #include "psa.h"
51 #include "cmh.h"
52 #include "psa_sim.h"
53 #include "cmh_sim.h"
54 #include "psa_mm.h"
55
56 #ifdef FF_ATI_BAT
57
58 #include "typedefs.h"
59 #include "gdd.h"
60 #include "bat.h"
61
62 #include "ati_bat.h"
63
64 #endif /* FF_ATI_BAT */
65
66 EXTERN T_ACI_CFUN_FUN CFUNfun;
67 EXTERN T_CIEV_SIGNAL_BUFFER asCievSignalBuf;
68 EXTERN T_CIEV_SMSFULL_BUFFER asCievSmsFullBuf;
69
70 /*
71 +--------------------------------------------------------------------+
72 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
73 | STATE : code ROUTINE : atPlusCops |
74 +--------------------------------------------------------------------+
75
76 PURPOSE : +COPS command (operator selection)
77 */
78
79 GLOBAL T_ATI_RSLT setatPlusCOPS (char *cl, UBYTE srcId)
80 {
81 CHAR op[MAX_ALPHA_OPER_LEN] = {0};
82 T_ACI_RETURN ret = AT_FAIL;
83 T_ACI_COPS_MOD mode = COPS_MOD_NotPresent;
84 T_ACI_COPS_FRMT format = COPS_FRMT_NotPresent;
85 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
86
87 TRACE_FUNCTION("setatPlusCops()");
88
89 if (CFUNfun NEQ CFUN_FUN_Full)
90 {
91 TRACE_EVENT_P1("+COPS error: cannot proceed Mobile has no Full CFUN: %d", CFUNfun);
92 cmdCmeError(CME_ERR_OpNotAllow);
93 return ATI_FAIL;
94 }
95
96 cl = parse (cl,"dds",&mode,&format,(LONG)(MAX_ALPHA_OPER_LEN-1),op); /*split parameter string in int,int,str*/
97 if (!cl OR ((mode EQ COPS_MOD_Man OR mode EQ COPS_MOD_Both)
98 AND op[0] EQ 0))
99 {
100 cmdCmeError(CME_ERR_OpNotAllow);
101 return ATI_FAIL;
102 }
103
104 #ifdef FF_ATI_BAT
105 {
106 T_BAT_cmd_send cmd;
107 T_BAT_cmd_set_plus_cops cops;
108 UBYTE len;
109
110 len=strlen(op);
111
112 /*
113 * If the operator name is too long we can't really do anything
114 * meaningful, so generate an error and give up.
115 */
116 if (len>BAT_MAX_COPS_OPER_LEN)
117 {
118 cmdCmeError(CME_ERR_Unknown);
119 return(ATI_FAIL);
120 }
121
122 cmd.ctrl_params = BAT_CMD_SET_PLUS_COPS;
123 cmd.params.ptr_set_plus_cops=&cops;
124
125 /*
126 * This relies on T_ACI_COPS_MOD and T_BAT_plus_cops_mode being
127 * equivalent.
128 */
129 cops.mode=(T_BAT_plus_cops_mode)mode;
130
131 /*
132 * This relies on T_ACI_COPS_FRMT and T_BAT_plus_cops_format being
133 * equivalent.
134 */
135 cops.format=(T_BAT_plus_cops_format)format;
136
137 cops.c_oper=(U8)len;
138
139 if (len)
140 {
141 memcpy(cops.oper,op,BAT_MAX_COPS_OPER_LEN);
142 cops.v_oper=TRUE;
143 }
144 else
145 {
146 cops.v_oper=FALSE;
147 }
148 bat_send(ati_bat_get_client(srcId), &cmd);
149 src_params->curAtCmd = AT_CMD_COPS;
150 return ATI_EXCT;
151 }
152 #else
153
154 ret = sAT_PlusCOPS ((T_ACI_CMD_SRC)srcId,mode,format,op);
155 switch (ret)
156 {
157 case (AT_CMPL): /*operation completed*/
158 break;
159 case (AT_EXCT):
160 src_params->curAtCmd = AT_CMD_COPS;
161 break;
162 default:
163 cmdCmeError(CME_ERR_Unknown); /*Command failed*/
164 break;
165 }
166 return (map_aci_2_ati_rslt(ret));
167
168 #endif /*FF_ATI_BAT*/
169 }
170
171 #ifdef FF_ATI_BAT
172 /*
173 +--------------------------------------------------------------------+
174 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
175 | STATE : code ROUTINE : aci_bat_HandleTestCOPS |
176 +--------------------------------------------------------------------+
177
178 PURPOSE :
179 */
180 T_ATI_RSLT atiHandleTestCOPS(UBYTE srcId)
181 {
182 T_BAT_cmd_send cmd;
183 T_BAT_no_parameter dummy;
184
185 cmd.ctrl_params = BAT_CMD_TST_PERCENT_COPS;
186 dummy.bat_dummy = 0xFF;
187 cmd.params.ptr_que_plus_cops = &dummy;
188
189 TRACE_FUNCTION("aci_bat_HandleTestCOPS() calls bat_send() <=== as APPLICATION");
190
191 #ifndef FF_DUAL_SIM
192 if (CFUNfun NEQ CFUN_FUN_Full)
193 {
194 cmdCmeError(CME_ERR_OpNotAllow);
195 return ATI_FAIL;
196 }
197 #endif /*FF_DUAL_SIM*/
198
199 bat_send(ati_bat_get_client(srcId), &cmd);
200 return ATI_EXCT; /* executing, because response is passed by callback function */
201 }
202
203 #else /* no FF_ATI_BAT */
204
205 GLOBAL T_ATI_RSLT atiHandleTestCOPS(char *cl, UBYTE srcId)
206 {
207 T_ACI_RETURN ret = AT_FAIL;
208 SHORT startIdx = 0,
209 lastIdx = 0,
210 i;
211 T_ACI_COPS_LST operLst;
212 BOOL END_OF_LIST = FALSE;
213
214
215 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
216 char* outputCommand;
217
218
219 TRACE_FUNCTION("atiHandleTestCOPS()");
220
221 #ifndef FF_DUAL_SIM
222 if (CFUNfun NEQ CFUN_FUN_Full)
223 {
224 cmdCmeError(CME_ERR_OpNotAllow);
225 return ATI_FAIL;
226 }
227 #endif /*FF_DUAL_SIM*/
228 do
229 {
230 startIdx += lastIdx;
231 switch (src_params->curAtCmd)
232 {
233 case AT_CMD_COPS:
234 ret = tAT_PlusCOPS((T_ACI_CMD_SRC)srcId,startIdx,&lastIdx,&operLst[0]);
235 break;
236 case AT_CMD_P_COPS:
237 ret = tAT_PercentCOPS((T_ACI_CMD_SRC)srcId,startIdx,&lastIdx,&operLst[0]);
238 break;
239 default:
240 cmdCmeError(CME_ERR_Unknown);
241 return ATI_FAIL;
242 }
243 if (ret EQ AT_CMPL)
244 {
245 for(i=0;i<lastIdx;i++)
246 {
247 if ((operLst[i].status < 0) AND (*operLst[i].numOper EQ 0))
248 {
249 END_OF_LIST = TRUE;
250 break;
251 }
252
253 /* What COPS command is active? */
254 switch (src_params->curAtCmd)
255 {
256 case AT_CMD_COPS:
257 outputCommand = "+COPS";
258 break;
259 case AT_CMD_P_COPS:
260 outputCommand ="%COPS";
261 break;
262 default:
263 cmdCmeError(CME_ERR_Unknown);
264 return ATI_FAIL;
265 }
266
267 sprintf(g_sa,"%s: %d,\"%s\",\"%s\",%s",outputCommand,
268 operLst[i].status,operLst[i].longOper,
269 operLst[i].shortOper,operLst[i].numOper);
270 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
271
272 }
273 }
274
275 switch(ret)
276 {
277 case AT_EXCT:
278 return ATI_EXCT;
279
280 case AT_FAIL:
281 cmdCmeError(CME_ERR_Unknown);
282 return ATI_FAIL;
283
284 case AT_BUSY:
285 return ATI_BUSY;
286
287 default:
288 break;/* Does nothing in this case */
289 }
290
291 }
292 while(!END_OF_LIST);
293
294 return ATI_CMPL;
295 }
296
297 #endif /* no FF_ATI_BAT */
298
299
300 GLOBAL T_ATI_RSLT tesatPlusCOPS (char *cl, UBYTE srcId)
301 {
302 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
303
304 #ifdef FF_ATI_BAT
305 TRACE_FUNCTION("tesatPlusCOPS() calls bat_send() <=== as APPLICATION");
306 return atiHandleTestCOPS(srcId);
307
308 #else /* FF_ATI_BAT */
309 TRACE_FUNCTION("tesatPlusCOPS()");
310 return atiHandleTestCOPS(cl,srcId);
311 #endif /* FF_ATI_BAT */
312
313 }
314
315 GLOBAL T_ATI_RSLT queatPlusCOPS (char *cl, UBYTE srcId)
316 {
317 CHAR op[MAX_ALPHA_OPER_LEN] = {0};
318 T_ACI_RETURN ret = AT_FAIL;
319 T_ACI_COPS_MOD mode = COPS_MOD_NotPresent;
320 T_ACI_COPS_FRMT format = COPS_FRMT_NotPresent;
321
322 TRACE_FUNCTION("queatPlusCops()");
323
324 #ifdef FF_ATI_BAT
325 {
326 T_BAT_cmd_send cmd;
327 T_BAT_no_parameter dummy;
328
329 cmd.ctrl_params = BAT_CMD_QUE_PLUS_COPS;
330 dummy.bat_dummy = 0xFF;
331 cmd.params.ptr_que_plus_cops = &dummy;
332 bat_send(ati_bat_get_client(srcId), &cmd);
333 return(ATI_EXCT);
334 }
335 #else /* no FF_ATI_BAT */
336
337 ret = qAT_PlusCOPS((T_ACI_CMD_SRC)srcId,&mode,&format,op);
338 if (ret EQ AT_CMPL)
339 {
340 if (*op)
341 sprintf(g_sa,"+COPS: %d,%d,\"%s\"",mode,format,op);
342 else
343 sprintf(g_sa,"+COPS: %d",mode);
344
345 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
346 }
347 else
348 {
349 cmdCmeError(CME_ERR_Unknown);
350 }
351 return (map_aci_2_ati_rslt(ret));
352
353 #endif /* no FF_ATI_BAT */
354 }
355
356 /*
357 +--------------------------------------------------------------------+
358 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
359 | STATE : code ROUTINE : setatPercentCOPS |
360 +--------------------------------------------------------------------+
361
362 PURPOSE : %COPS command (operator selection)
363 */
364
365 GLOBAL T_ATI_RSLT setatPercentCOPS (char *cl, UBYTE srcId)
366 {
367 CHAR op[MAX_ALPHA_OPER_LEN] = {0};
368 T_ACI_RETURN ret = AT_FAIL;
369 T_ACI_COPS_MOD mode = COPS_MOD_NotPresent;
370 T_ACI_COPS_FRMT format = COPS_FRMT_NotPresent;
371 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
372
373 if (CFUNfun NEQ CFUN_FUN_Full)
374 {
375 TRACE_EVENT_P1("%COPS error: cannot proceed Mobile has no Full CFUN: %d", CFUNfun);
376 cmdCmeError(CME_ERR_OpNotAllow);
377 return ATI_FAIL;
378 }
379 cl = parse (cl,"dds",&mode,&format,(LONG)(MAX_ALPHA_OPER_LEN-1),op); /*split parameter string in int,int,str*/
380 if (!cl) /*For %COPS, Manual selection without Operator parameter is allowed */
381 {
382 cmdCmeError(CME_ERR_OpNotAllow);
383 return ATI_FAIL;
384 }
385
386 #ifdef FF_ATI_BAT
387 {
388 T_BAT_cmd_send cmd;
389 T_BAT_cmd_set_percent_cops my_bat_set_percent_cops;
390 UBYTE OperLength = strlen(op);
391
392 TRACE_FUNCTION("setatPercentCOPS() calls bat_send() <=== as APPLICATION");
393
394 memset(&my_bat_set_percent_cops, sizeof(my_bat_set_percent_cops), FALSE);
395 cmd.ctrl_params = BAT_CMD_SET_PERCENT_COPS;
396 cmd.params.ptr_set_percent_cops = &my_bat_set_percent_cops;
397
398 my_bat_set_percent_cops.mode = (T_BAT_VAL_percent_cops_mode)mode;
399 my_bat_set_percent_cops.format = (T_BAT_VAL_percent_cops_format)format;
400
401 if (OperLength NEQ 0 AND
402 OperLength <= BAT_MAX_COPS_LONG_OPER_LEN)
403 {
404 memcpy(&my_bat_set_percent_cops.oper, op, BAT_MAX_COPS_LONG_OPER_LEN);
405 }
406
407 src_params->curAtCmd = AT_CMD_P_COPS;
408
409 bat_send(ati_bat_get_client(srcId), &cmd);
410 return ATI_EXCT; /* executing, because response is passed by callback function */
411 }
412
413 #else /* no FF_ATI_BAT */
414
415 TRACE_FUNCTION("setatPercentCOPS()");
416 ret = sAT_PercentCOPS ((T_ACI_CMD_SRC)srcId,mode,format,op);
417 switch (ret)
418 {
419 case (AT_CMPL): /*operation completed*/
420 break;
421 case (AT_EXCT):
422 src_params->curAtCmd = AT_CMD_P_COPS;
423 break;
424 default:
425 cmdCmeError(CME_ERR_Unknown); /*Command failed*/
426 break;
427 }
428 return (map_aci_2_ati_rslt(ret));
429
430 #endif /* no FF_ATI_BAT */
431 }
432
433
434 /*
435 +--------------------------------------------------------------------+
436 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
437 | STATE : code ROUTINE : tesatPercentCOPS |
438 +--------------------------------------------------------------------+
439
440 PURPOSE : %COPS command (operator test)
441 */
442
443
444 GLOBAL T_ATI_RSLT tesatPercentCOPS (char *cl, UBYTE srcId)
445 {
446 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
447
448 #ifdef FF_ATI_BAT
449 TRACE_FUNCTION("tesatPercentCOPS() calls bat_send() <=== as APPLICATION");
450 return atiHandleTestCOPS(srcId);
451
452 #else /* FF_ATI_BAT */
453 TRACE_FUNCTION("tesatPercentCOPS()");
454 return atiHandleTestCOPS(cl,srcId);
455 #endif /* FF_ATI_BAT */
456 }
457
458 /*
459 +--------------------------------------------------------------------+
460 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
461 | STATE : code ROUTINE : queatPercentCOPS |
462 +--------------------------------------------------------------------+
463
464 PURPOSE : %COPS command (operator query)
465 */
466
467
468 GLOBAL T_ATI_RSLT queatPercentCOPS (char *cl, UBYTE srcId)
469 {
470 CHAR op[MAX_ALPHA_OPER_LEN] = {0};
471 T_ACI_RETURN ret = AT_FAIL;
472 T_ACI_COPS_MOD mode = COPS_MOD_NotPresent;
473 T_ACI_COPS_FRMT format = COPS_FRMT_NotPresent;
474 T_ACI_COPS_SVST svrStatus = COPS_SVST_NotPresent;
475
476 #ifdef FF_ATI_BAT
477 {
478 T_BAT_cmd_send cmd;
479 T_BAT_no_parameter dummy;
480
481 TRACE_FUNCTION("queatPercentCOPS() calls bat_send() <=== as APPLICATION");
482 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_COPS;
483 dummy.bat_dummy = 0xFF;
484 cmd.params.ptr_que_percent_cops = &dummy;
485 bat_send(ati_bat_get_client(srcId), &cmd);
486 return ATI_EXCT; /* executing, because response is passed by callback function */
487 }
488 #else /* no FF_ATI_BAT */
489
490 TRACE_FUNCTION("queatPercentCOPS()");
491
492 ret = qAT_PercentCOPS((T_ACI_CMD_SRC)srcId,&mode,&format,&svrStatus,op);
493 if (ret EQ AT_CMPL)
494 {
495 /* Added an empty comma and the service Status parameter */
496 sprintf(g_sa,"%s: %d,%d,\"%s\",,%d","%COPS",mode,format,op,svrStatus);
497 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
498
499 }
500 else
501 {
502 cmdCmeError(CME_ERR_Unknown); /*command failed*/
503 }
504 return (map_aci_2_ati_rslt(ret));
505
506 #endif /* no FF_ATI_BAT */
507 }
508
509
510
511 /*
512 +--------------------------------------------------------------------+
513 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
514 | STATE : code ROUTINE : setatPercentCREG |
515 +--------------------------------------------------------------------+
516
517 PURPOSE : %CREG command (Network registration)
518 */
519
520 GLOBAL T_ATI_RSLT setatPercentCREG (char *cl, UBYTE srcId)
521 {
522 T_ATI_CREG_MOD mode=CREG_MOD_OFF;
523
524 TRACE_FUNCTION("setatPercentCREG()");
525
526 cl=parse(cl,"d",&mode);
527
528 switch(mode)
529 {
530 case CREG_MOD_OFF:
531 case CREG_MOD_ON:
532 case CREG_MOD_LOC_INF_ON:
533 /* user wants to set mode: reset CREG related ATI parameters */
534 ati_creg_init(srcId, PercentCREG_CMD);
535 ati_user_output_cfg[srcId].percent_creg.mod_lac_cid.pres_mode = mode;
536 return ATI_CMPL;
537
538 default:
539 cmdCmeError(CME_ERR_OpNotAllow);
540 return ATI_FAIL;
541 }
542 }
543
544
545 /*
546 +--------------------------------------------------------------------+
547 | PROJECT : GPRS (8441) MODULE : GACI_CMD |
548 | STATE : code ROUTINE : queatPercentCREG |
549 +--------------------------------------------------------------------+
550
551 PURPOSE : %CREG command
552 */
553 GLOBAL T_ATI_RSLT queatPercentCREG (char *cl, UBYTE srcId)
554 {
555
556 #ifndef FF_ATI_BAT
557 T_ACI_CREG_STAT stat;
558 USHORT lac, cid;
559 T_ATI_CREG_MOD mode;
560 T_ACI_P_CREG_GPRS_IND gprs_ind;
561 short pos;
562 U8 rt;
563 #endif
564
565 TRACE_FUNCTION("queatPercentCREG()");
566
567 #ifdef FF_ATI_BAT
568 {
569 T_BAT_cmd_send cmd;
570 T_BAT_no_parameter dummy;
571
572 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_CREG;
573 dummy.bat_dummy = 0xFF;
574 cmd.params.ptr_que_percent_creg = &dummy;
575 bat_send(ati_bat_get_client(srcId), &cmd);
576 return(ATI_EXCT);
577 }
578 #else /* no FF_ATI_BAT */
579
580 mode = ati_user_output_cfg[srcId].percent_creg.mod_lac_cid.pres_mode;
581
582 if (qAT_PercentCREG((T_ACI_CMD_SRC)srcId, &stat, &lac, &cid, &gprs_ind, &rt) NEQ AT_CMPL)
583 {
584 cmdCmeError(CME_ERR_Unknown);
585 return ATI_FAIL;
586 }
587
588 pos = sprintf(g_sa, "%s: %d,%d", "%CREG", mode, stat);
589
590 if ( (mode EQ CREG_MOD_LOC_INF_ON) AND
591 (stat EQ CREG_STAT_Reg OR stat EQ CREG_STAT_Roam) )
592 pos += sprintf(g_sa+pos, ",\"%04X\",\"%04X\"", lac, cid);
593 else
594 pos += sprintf(g_sa+pos, ",,");
595
596 sprintf(g_sa+pos,",%d", gprs_ind);
597
598 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
599 return ATI_CMPL;
600
601 #endif /* no FF_ATI_BAT */
602 }
603
604 /*
605 +--------------------------------------------------------------------+
606 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
607 | STATE : code ROUTINE : setatPlusCREG |
608 +--------------------------------------------------------------------+
609
610 PURPOSE : +CREG command (Network registration)
611 */
612
613 GLOBAL T_ATI_RSLT setatPlusCREG (char *cl, UBYTE srcId)
614 {
615 T_ATI_CREG_MOD mode=CREG_MOD_OFF;
616
617 TRACE_FUNCTION("setatPlusCREG()");
618
619 cl=parse(cl,"d",&mode);
620
621 switch(mode)
622 {
623 case CREG_MOD_OFF:
624 case CREG_MOD_ON:
625 case CREG_MOD_LOC_INF_ON:
626 /* user wants to set mode: reset CREG related ATI parameters */
627 ati_creg_init(srcId, CREG_CMD);
628 ati_user_output_cfg[srcId].creg.mod_lac_cid.pres_mode = mode;
629 return ATI_CMPL;
630
631 default:
632 cmdCmeError(CME_ERR_OpNotAllow);
633 return ATI_FAIL;
634 }
635 }
636
637 GLOBAL T_ATI_RSLT queatPlusCREG (char *cl, UBYTE srcId)
638 {
639 T_ACI_CREG_STAT stat;
640 USHORT lac, cid;
641 T_ATI_CREG_MOD mode;
642 short pos;
643
644 TRACE_FUNCTION("queatPlusCREG()");
645
646 mode = ati_user_output_cfg[srcId].creg.mod_lac_cid.pres_mode;
647
648 if (qAT_PlusCREG((T_ACI_CMD_SRC)srcId, &stat, &lac, &cid) NEQ AT_CMPL)
649 {
650 cmdCmeError(CME_ERR_Unknown);
651 return ATI_FAIL;
652 }
653
654 pos = sprintf(g_sa, "+CREG: %d,%d", mode, stat);
655
656 if (mode EQ CREG_MOD_LOC_INF_ON)
657 {
658 if (stat EQ CREG_STAT_Reg OR stat EQ CREG_STAT_Roam)
659 sprintf(g_sa+pos, ",\"%04X\",\"%04X\"", lac, cid);
660 }
661
662 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
663 return ATI_CMPL;
664 }
665
666
667
668
669 /*
670 +--------------------------------------------------------------------+
671 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
672 | STATE : code ROUTINE : atPlusCopn |
673 +--------------------------------------------------------------------+
674
675 PURPOSE : +COPN command (read operator names)
676 */
677
678 GLOBAL T_ATI_RSLT setatPlusCOPN (char *cl, UBYTE srcId)
679 {
680 SHORT startIdx, lastIdx;
681 T_ACI_COPN_LST operLst;
682 UBYTE idx;
683 BOOL loop;
684 BOOL ret;
685
686 TRACE_FUNCTION("setatPlusCOPN()");
687
688 /* read out the PCM list */
689 startIdx = 0;
690 loop = TRUE;
691
692 do
693 {
694 if ( qAT_PlusCOPN((T_ACI_CMD_SRC)srcId, COPN_LID_Pcm, startIdx,
695 &lastIdx, operLst) EQ AT_FAIL )
696 break;
697
698 for( idx=0; idx < MAX_OPER; idx++ )
699 {
700 if ( operLst[idx].numOper[0] EQ 0x0 )
701 {
702 loop = FALSE;
703 break;
704 }
705
706 sprintf(g_sa,"+COPN: \"%s\",\"%s\"",operLst[idx].numOper,
707 operLst[idx].alphaOper );
708 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
709 }
710 startIdx = lastIdx+1;
711 }
712 while( loop );
713
714 /* read out the constant list */
715 startIdx = 0;
716
717 ret = cmd_readCOPNBlock(startIdx,srcId);
718
719 if (ret EQ TRUE)
720 return ATI_CMPL;
721 else
722 return ATI_EXCT;
723
724 }
725
726 /*
727 +--------------------------------------------------------------------+
728 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
729 | STATE : code ROUTINE : setatPercentCOPN |
730 +--------------------------------------------------------------------+
731
732 PURPOSE : %COPN command (get MCC and MNC, long name or short name given one of the them)
733 */
734
735 GLOBAL T_ATI_RSLT setatPercentCOPN (char *cl, UBYTE srcId)
736 {
737 T_ACI_COPS_FRMT format = COPS_FRMT_NotPresent;
738 CHAR op[MAX_ALPHA_OPER_LEN] = {0};
739 T_ACI_OPER_NTRY * oper_ntry;
740 USHORT i;
741
742 TRACE_FUNCTION ("setatPercentCOPN()");
743
744 cl = parse (cl,"ds", &format, (LONG)MAX_ALPHA_OPER_LEN, op);
745
746 if ((!cl) OR (format < COPS_FRMT_Long) OR (format > COPS_FRMT_Numeric) OR *op EQ '\0')
747 {
748 cmdCmeError(CME_ERR_OpNotAllow);
749 return ATI_FAIL;
750 }
751
752 if (format EQ COPS_FRMT_Numeric)
753 {
754 if ((strlen(op) NEQ (SIZE_MNC + SIZE_MCC -1)) AND
755 (strlen(op) NEQ (SIZE_MNC + SIZE_MCC)))
756 {
757 cmdCmeError(CME_ERR_OpNotAllow);
758 return ATI_FAIL;
759 }
760
761 for (i = 0; *(op+i) NEQ '\0'; i ++)
762 {
763 if (!((*(op+i) >= '0')AND(*(op+i) <= '9')))
764 {
765 cmdCmeError(CME_ERR_OpNotAllow);
766 return ATI_FAIL;
767 }
768 }
769 }
770
771 ACI_MALLOC (oper_ntry, sizeof (T_ACI_OPER_NTRY));
772
773 if (qAT_PercentCOPN( (T_ACI_CMD_SRC)srcId, format, op, oper_ntry) EQ AT_FAIL)
774 {
775 sprintf (g_sa, "%s", "%COPN: ");
776 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
777 ACI_MFREE (oper_ntry);
778 return ATI_CMPL;
779 }
780
781 if ((oper_ntry->mnc & 0x00F) EQ 0xF)
782 {
783 sprintf (g_sa, "%s\"%s\",\"%s\",\"%03X%02X\",%d", "%COPN: ", oper_ntry->longName, oper_ntry->shrtName,
784 oper_ntry->mcc, oper_ntry->mnc >> 4, oper_ntry->source);
785 }
786 else
787 {
788 sprintf (g_sa, "%s\"%s\",\"%s\",\"%03X%03X\",%d", "%COPN: ", oper_ntry->longName, oper_ntry->shrtName,
789 oper_ntry->mcc, oper_ntry->mnc, oper_ntry->source);
790 }
791 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
792
793 ACI_MFREE (oper_ntry);
794 return ATI_CMPL;
795
796
797 }
798
799 #ifdef TI_PS_FF_AT_CMD_WS46
800 /*
801 +--------------------------------------------------------------------+
802 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
803 | STATE : code ROUTINE : atPlusWS46 |
804 +--------------------------------------------------------------------+
805
806 PURPOSE : +WS46 command (select wireless network)
807 */
808
809 GLOBAL T_ATI_RSLT setatPlusWS46 (char *cl, UBYTE srcId)
810 {
811 T_ACI_RETURN ret = AT_FAIL;
812 T_ACI_WS46_MOD mode=WS46_MOD_NotPresent;
813
814 TRACE_FUNCTION("setatPLusWS46()");
815
816 cl = parse(cl,"d",&mode);
817 if (!cl)
818 {
819 cmdCmeError(CME_ERR_OpNotAllow);
820 return ATI_FAIL;
821 }
822
823 #ifdef FF_ATI_BAT
824
825 {
826 T_BAT_cmd_send cmd;
827 T_BAT_cmd_set_plus_ws46 ws46;
828
829 cmd.ctrl_params = BAT_CMD_SET_PLUS_WS46;
830 cmd.params.ptr_set_plus_ws46=&ws46;
831
832 ws46.n=(T_BAT_plus_ws46_n)mode;
833
834 bat_send(ati_bat_get_client(srcId), &cmd);
835 return(ATI_EXCT);
836 }
837
838 #else /* no FF_ATI_BAT */
839
840 ret=sAT_PlusWS46((T_ACI_CMD_SRC)srcId,mode);
841
842 if (ret EQ AT_CMPL)
843 {
844 return ATI_CMPL;
845 }
846 else
847 {
848 cmdCmeError(CME_ERR_OpNotAllow);
849 return ATI_FAIL;
850 }
851
852 #endif /* no FF_ATI_BAT */
853 }
854
855 GLOBAL T_ATI_RSLT queatPlusWS46 (char *cl, UBYTE srcId)
856 {
857 T_ACI_RETURN ret = AT_FAIL;
858 T_ACI_WS46_MOD mode=WS46_MOD_NotPresent;
859
860 TRACE_FUNCTION("queatPLusWS46()");
861
862 #ifdef FF_ATI_BAT
863 {
864 T_BAT_cmd_send cmd;
865 T_BAT_no_parameter dummy;
866
867 cmd.ctrl_params = BAT_CMD_QUE_PLUS_WS46;
868 dummy.bat_dummy = 0xFF;
869 cmd.params.ptr_que_plus_ws46 = &dummy;
870 bat_send(ati_bat_get_client(srcId), &cmd);
871 return(ATI_EXCT);
872 }
873 #else /* no FF_ATI_BAT */
874
875 ret = qAT_PlusWS46((T_ACI_CMD_SRC)srcId,&mode);
876
877 if (ret EQ AT_CMPL)
878 {
879 resp_disp(srcId, cl,"e",&mode);
880 return ATI_CMPL;
881 }
882 else if (ret EQ AT_FAIL)
883 {
884 cmdCmeError(CME_ERR_OpNotAllow);
885 return ATI_FAIL;
886 }
887 return (map_aci_2_ati_rslt(ret));
888
889 #endif /* no FF_ATI_BAT */
890 }
891 #endif /* TI_PS_FF_WS46 */
892 /*
893 +--------------------------------------------------------------------+
894 | PROJECT : GSM-F&D (8411) MODULE : |
895 | STATE : code ROUTINE : setatPercentCHPL |
896 +--------------------------------------------------------------------+
897
898 PURPOSE : show list of all available entries in the SIM field EF_HPLMNwAcT.
899
900 Command Possible Response
901 %CHPL=oprFrmt %CHPL: <opr>
902 %CHPL=? %CHPL: (list of supported <oprFrmt>s)
903
904 <oprFrmt>:
905 0 long format alphanumeric <opr>
906 1 short format alphanumeric <opr>
907 2 numeric <opr>
908
909 <opr>: string type; <oprFrmt> indicates if the format is
910 alphanumeric or numeric.
911 Long alphanumeric can be up to 16 characters.
912 Short alphanumeric can be up to 8 characters.
913
914 Numeric format is the GSM LAI number, which consists of:
915 3 BCD country code.
916 2 BCD network code.
917
918 The returned <opr> string shall not be in BCD format, but
919 in IRA characters converted from BCD. Hence the number
920 will have the structure (CC digit 3)(CC digit 2)(CC digit 1)
921 (NW digit 2)(NW digit 1).
922
923 */
924
925 GLOBAL T_ATI_RSLT setatPercentCHPL( char *cl, UBYTE srcId )
926 {
927 T_ACI_CHPL_FRMT format = CHPL_FRMT_NotPresent;
928
929 #ifndef FF_ATI_BAT
930 T_ACI_OPER_NTRY oper;
931 #endif
932
933 T_ACI_RETURN ret = AT_FAIL;
934
935 TRACE_FUNCTION( "setatPercentCHPL()" );
936
937 if (CFUNfun NEQ CFUN_FUN_Full)
938 {
939 TRACE_EVENT_P1("+COPS error: cannot proceed Mobile has no Full CFUN: %d", CFUNfun);
940 cmdCmeError(CME_ERR_OpNotAllow);
941 return ATI_FAIL;
942 }
943
944 /* parse mode */
945 cl = parse (cl, "d", &format);
946 if ((!cl) OR (format > CHPL_FRMT_Numeric) OR (format < CHPL_FRMT_NotPresent))
947 {
948 cmdCmeError (CME_ERR_OpNotAllow);
949 return (ATI_FAIL);
950 }
951
952 #ifdef FF_ATI_BAT
953
954 {
955 T_BAT_cmd_send cmd;
956 T_BAT_cmd_set_percent_chpl chpl;
957
958 cmd.ctrl_params = BAT_CMD_SET_PERCENT_CHPL;
959 cmd.params.ptr_set_percent_chpl=&chpl;
960
961 /*
962 * This relies on T_ACI_CHPL_FRMT and T_BAT_percent_chpl_oprfrmt being
963 * identical.
964 */
965 chpl.oprfrmt=(T_BAT_percent_chpl_oprfrmt)format;
966
967 bat_send(ati_bat_get_client(srcId), &cmd);
968 return(ATI_EXCT);
969 }
970
971 #else /* no FF_ATI_BAT */
972
973 ret = sAT_PercentCHPL ((T_ACI_CMD_SRC)srcId, &oper);
974 if (ret NEQ AT_CMPL)
975 {
976 cmdCmeError(CME_ERR_Unknown);
977 return (ATI_FAIL);
978 }
979
980 switch (format)
981 {
982 case CHPL_FRMT_Long :
983 sprintf(g_sa, "%s: %s", "%CHPL", oper.longName);
984 break;
985
986 case CHPL_FRMT_Short :
987 sprintf(g_sa, "%s: %s", "%CHPL", oper.shrtName);
988 break;
989
990 case CHPL_FRMT_Numeric :
991 if ((oper.mnc & 0x00F) EQ 0xF)
992 /*lint -e{702} */
993 sprintf(g_sa, "%s: %03x,%02x", "%CHPL", oper.mcc, oper.mnc >> 4);
994 else
995 sprintf(g_sa, "%s: %03x,%03x", "%CHPL", oper.mcc, oper.mnc);
996 break;
997
998 default :
999 cmdCmeError(CME_ERR_Unknown);
1000 return (ATI_FAIL);
1001 }
1002 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT);
1003
1004 return(ATI_CMPL);
1005
1006 #endif /* no FF_ATI_BAT */
1007 }
1008
1009 /*
1010 +--------------------------------------------------------------------+
1011 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1012 | STATE : code ROUTINE : setatPlusCTZR |
1013 +--------------------------------------------------------------------+
1014
1015 PURPOSE : %CTZR command (Timezone Mode)
1016 */
1017 GLOBAL T_ATI_RSLT setatPlusCTZR (char *cl, UBYTE srcId)
1018 {
1019 T_ACI_CTZR_MODE mode = CTZR_MODE_OFF; /* CTZR */
1020 T_ACI_RETURN ret = AT_FAIL;
1021
1022 TRACE_FUNCTION( "setatPlusCTZR()" );
1023
1024 /* parse mode */
1025 cl = parse (cl, "d", &mode);
1026 if ((!cl) OR (mode > CTZR_MODE_ON) OR (mode < CTZR_MODE_OFF))/*lint !e685 (Warning -- 685: Relational operator '>' always evaluates to 'false ) */
1027 {
1028 cmdCmeError (CME_ERR_OpNotAllow);
1029 return (ATI_FAIL);
1030 }
1031
1032 ret = sAT_PlusCTZR ((T_ACI_CMD_SRC)srcId, mode);
1033
1034 switch (ret)
1035 {
1036 case (AT_CMPL): /*operation completed*/
1037 break;
1038
1039 default:
1040 cmdCmeError(CME_ERR_Unknown); /*Command failed*/
1041 break;
1042 }
1043 return (map_aci_2_ati_rslt(ret));
1044
1045 }
1046
1047 /*
1048 +--------------------------------------------------------------------+
1049 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1050 | STATE : code ROUTINE : queatPlusCTZR |
1051 +--------------------------------------------------------------------+
1052
1053 PURPOSE : %CTZR command (Timezone Mode)
1054 */
1055 GLOBAL T_ATI_RSLT queatPlusCTZR (char *cl, UBYTE srcId)
1056 {
1057 T_ACI_CTZR_MODE mode;
1058 T_ACI_RETURN ret = AT_FAIL;
1059
1060 TRACE_FUNCTION("queatPlusCTZR()");
1061
1062 ret = qAT_PlusCTZR((T_ACI_CMD_SRC)srcId, &mode);
1063 if (ret NEQ AT_CMPL)
1064 {
1065 cmdCmeError(CME_ERR_Unknown);
1066 return (ATI_FAIL);
1067 }
1068
1069 sprintf(g_sa,"+CTZR: %d", mode);
1070 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
1071
1072 return ATI_CMPL;
1073 }
1074
1075 /*
1076 +--------------------------------------------------------------------+
1077 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1078 | STATE : code ROUTINE : setatPlusCTZU |
1079 +--------------------------------------------------------------------+
1080
1081 PURPOSE : +CTZU command (Timezone Update)
1082 */
1083 GLOBAL T_ATI_RSLT setatPlusCTZU (char *cl, UBYTE srcId)
1084 {
1085 T_ACI_CTZU_MODE mode = CTZU_MODE_OFF; /* CTZU */
1086 T_ACI_RETURN ret = AT_FAIL;
1087
1088 TRACE_FUNCTION( "setatPlusCTZU()" );
1089
1090 /* parse mode */
1091 cl = parse (cl, "d", &mode);
1092 if ((!cl) OR (mode > CTZU_MODE_ON) OR (mode < CTZU_MODE_OFF))/*lint !e685 (Warning -- 685: Relational operator '>' always evaluates to 'false ) */
1093 {
1094 cmdCmeError (CME_ERR_OpNotAllow);
1095 return (ATI_FAIL);
1096 }
1097
1098 #ifdef FF_ATI_BAT
1099
1100 {
1101 T_BAT_cmd_send cmd;
1102 T_BAT_cmd_set_plus_ctzu ctzu;
1103
1104 cmd.ctrl_params = BAT_CMD_SET_PLUS_CTZU;
1105 cmd.params.ptr_set_plus_ctzu=&ctzu;
1106
1107 /*
1108 * This relies on T_ACI_CTZU_MODE and T_BAT_plus_ctzu_onoff being
1109 * identical.
1110 */
1111 ctzu.onoff=(T_BAT_plus_ctzu_onoff)mode;
1112
1113 bat_send(ati_bat_get_client(srcId), &cmd);
1114 return(ATI_EXCT);
1115 }
1116
1117 #else /* no FF_ATI_BAT */
1118
1119 ret = sAT_PlusCTZU ((T_ACI_CMD_SRC)srcId, mode);
1120
1121 switch (ret)
1122 {
1123 case (AT_CMPL): /*operation completed*/
1124 break;
1125
1126 default:
1127 cmdCmeError(CME_ERR_Unknown); /*Command failed*/
1128 break;
1129 }
1130 return (map_aci_2_ati_rslt(ret));
1131
1132 #endif /* no FF_ATI_BAT */
1133 }
1134
1135
1136 /*
1137 +--------------------------------------------------------------------+
1138 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1139 | STATE : code ROUTINE : setatPercentCTZV |
1140 +--------------------------------------------------------------------+
1141
1142 PURPOSE : %CTZV command (time and date report)
1143 */
1144 GLOBAL T_ATI_RSLT setatPercentCTZV (char *cl, UBYTE srcId)
1145 {
1146 T_ACI_PCTZV_MODE mode = PCTZV_MODE_OFF; /* %CTZV */
1147 T_ACI_RETURN ret = AT_FAIL;
1148
1149 TRACE_FUNCTION( "setatPercentCTZV()" );
1150
1151 /* parse mode */
1152 cl = parse (cl, "d", &mode);
1153 if ((!cl) OR (mode > PCTZV_MODE_ON) OR (mode < PCTZV_MODE_OFF))/*lint !e685 (Warning -- 685: Relational operator '>' always evaluates to 'false ) */
1154 {
1155 cmdCmeError (CME_ERR_OpNotAllow);
1156 return (ATI_FAIL);
1157 }
1158
1159 ret = sAT_PercentCTZV ((T_ACI_CMD_SRC)srcId, mode);
1160
1161 switch (ret)
1162 {
1163 case (AT_CMPL): /*operation completed*/
1164 break;
1165
1166 default:
1167 cmdCmeError(CME_ERR_Unknown); /*Command failed*/
1168 break;
1169 }
1170 return (map_aci_2_ati_rslt(ret));
1171
1172 }
1173
1174
1175
1176 /*
1177 +--------------------------------------------------------------------+
1178 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1179 | STATE : code ROUTINE : setatPercentCNIV |
1180 +--------------------------------------------------------------------+
1181
1182 PURPOSE : %CNIV command (network identity report)
1183 */
1184 GLOBAL T_ATI_RSLT setatPercentCNIV (char *cl, UBYTE srcId)
1185 {
1186 T_ACI_CNIV_MODE mode = CNIV_MODE_OFF; /* CNIV */
1187 T_ACI_RETURN ret = AT_FAIL;
1188
1189 TRACE_FUNCTION( "setatPercentCNIV()" );
1190
1191 /* parse mode */
1192 cl = parse (cl, "d", &mode);
1193 if ((!cl) OR (mode > CNIV_MODE_ON) OR (mode < CNIV_MODE_OFF))/*lint !e685 (Warning -- 685: Relational operator '>' always evaluates to 'false ) */
1194 {
1195 cmdCmeError (CME_ERR_OpNotAllow);
1196 return (ATI_FAIL);
1197 }
1198
1199 #ifdef FF_ATI_BAT
1200 {
1201 T_BAT_cmd_send cmd;
1202 T_BAT_cmd_set_percent_cniv my_bat_set_percent_cniv;
1203
1204 memset(&my_bat_set_percent_cniv, 0 , sizeof(my_bat_set_percent_cniv));
1205 cmd.ctrl_params = BAT_CMD_SET_PERCENT_CNIV;
1206 cmd.params.ptr_set_percent_cniv = &my_bat_set_percent_cniv;
1207
1208 my_bat_set_percent_cniv.mode= (T_BAT_VAL_percent_cniv_mode)mode;
1209
1210 bat_send(ati_bat_get_client(srcId), &cmd);
1211 return ATI_EXCT; /* executing, because response is passed by callback function */
1212 }
1213 #else
1214 {
1215 ret = sAT_PercentCNIV ((T_ACI_CMD_SRC)srcId, mode);
1216
1217 switch (ret)
1218 {
1219 case (AT_CMPL): /*operation completed*/
1220 break;
1221
1222 default:
1223 cmdCmeError(CME_ERR_Unknown); /*Command failed*/
1224 break;
1225 }
1226 return (map_aci_2_ati_rslt(ret));
1227 }
1228 #endif /* FF_ATI_BAT */
1229 }
1230
1231 /*
1232 +--------------------------------------------------------------------+
1233 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1234 | STATE : code ROUTINE : queatPlusCTZU |
1235 +--------------------------------------------------------------------+
1236
1237 PURPOSE : +CTZU query command (Timezone update)
1238 */
1239 GLOBAL T_ATI_RSLT queatPlusCTZU (char *cl, UBYTE srcId)
1240 {
1241 #ifndef FF_ATI_BAT
1242 T_ACI_CTZU_MODE mode;
1243 T_ACI_RETURN ret = AT_FAIL;
1244 #endif
1245
1246 TRACE_FUNCTION("queatPlusCTZU()");
1247
1248 #ifdef FF_ATI_BAT
1249 {
1250 T_BAT_cmd_send cmd;
1251 T_BAT_no_parameter dummy;
1252
1253 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CTZU;
1254 dummy.bat_dummy = 0xFF;
1255 cmd.params.ptr_que_plus_ctzu = &dummy;
1256 bat_send(ati_bat_get_client(srcId), &cmd);
1257 return(ATI_EXCT);
1258 }
1259 #else /* no FF_ATI_BAT */
1260
1261 ret = qAT_PlusCTZU((T_ACI_CMD_SRC)srcId, &mode);
1262 if (ret NEQ AT_CMPL)
1263 {
1264 cmdCmeError(CME_ERR_Unknown);
1265 return (ATI_FAIL);
1266 }
1267
1268 sprintf(g_sa,"+CTZU: %d", mode);
1269 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
1270
1271 return ATI_CMPL;
1272
1273 #endif /* no FF_ATI_BAT */
1274 }
1275
1276
1277
1278 /*
1279 +--------------------------------------------------------------------+
1280 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1281 | STATE : code ROUTINE : queatPercentCTZV |
1282 +--------------------------------------------------------------------+
1283
1284 PURPOSE : %CTZV command (time and date report)
1285 */
1286 GLOBAL T_ATI_RSLT queatPercentCTZV (char *cl, UBYTE srcId)
1287 {
1288 T_ACI_PCTZV_MODE mode;
1289 T_ACI_RETURN ret = AT_FAIL;
1290
1291 TRACE_FUNCTION("queatPercentCTZV()");
1292
1293 ret = qAT_PercentCTZV((T_ACI_CMD_SRC)srcId, &mode);
1294 if (ret NEQ AT_CMPL)
1295 {
1296 cmdCmeError(CME_ERR_Unknown);
1297 return (ATI_FAIL);
1298 }
1299
1300 sprintf(g_sa,"%s: %d","%CTZV", mode);
1301 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
1302
1303 return ATI_CMPL;
1304 }
1305
1306
1307 /*
1308 +--------------------------------------------------------------------+
1309 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1310 | STATE : code ROUTINE : queatPercentCNIV |
1311 +--------------------------------------------------------------------+
1312
1313 PURPOSE : %CNIV command (time and date report)
1314 */
1315 GLOBAL T_ATI_RSLT queatPercentCNIV (char *cl, UBYTE srcId)
1316 {
1317
1318 TRACE_FUNCTION("queatPercentCNIV()");
1319
1320 #ifdef FF_ATI_BAT
1321 {
1322 T_BAT_cmd_send cmd;
1323 T_BAT_no_parameter dummy;
1324
1325 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_CNIV;
1326 dummy.bat_dummy = 0xFF;
1327 cmd.params.ptr_que_percent_cniv= &dummy;
1328
1329 bat_send(ati_bat_get_client(srcId), &cmd);
1330
1331 return(ATI_EXCT);
1332 }
1333 #else
1334 {
1335 T_ACI_CNIV_MODE mode;
1336 T_ACI_RETURN ret = AT_FAIL;
1337
1338 ret = qAT_PercentCNIV((T_ACI_CMD_SRC)srcId, &mode);
1339 if (ret NEQ AT_CMPL)
1340 {
1341 cmdCmeError(CME_ERR_Unknown);
1342 return (ATI_FAIL);
1343 }
1344 sprintf(g_sa,"%s: %d","%CNIV", mode);
1345 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
1346
1347 return ATI_CMPL;
1348 }
1349 #endif /*FF_ATI_BAT*/
1350 }
1351
1352 /*
1353 +--------------------------------------------------------------------+
1354 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1355 | STATE : code ROUTINE : setatPercentTREG |
1356 +--------------------------------------------------------------------+
1357
1358 PURPOSE : %CWUP command (force power campaign)
1359 */
1360
1361 GLOBAL T_ATI_RSLT setatPercentCWUP (char *cl, UBYTE srcId)
1362 {
1363 T_ACI_RETURN ret = AT_FAIL;
1364 T_ACI_CWUP_TYPE type;
1365
1366 TRACE_FUNCTION( "setatPercentCWUP()" );
1367
1368 /* parse mode */
1369 cl = parse (cl, "d", &type);
1370 if ((!cl) OR (type NEQ CWUP_TYPE_RR))
1371 {
1372 cmdCmeError (CME_ERR_OpNotAllow);
1373 return (ATI_FAIL);
1374 }
1375
1376 #ifdef FF_ATI_BAT
1377
1378 {
1379 T_BAT_cmd_send cmd;
1380 T_BAT_cmd_set_percent_cwup cwup;
1381
1382 cmd.ctrl_params = BAT_CMD_SET_PERCENT_CWUP;
1383 cmd.params.ptr_set_percent_cwup=&cwup;
1384
1385 /*
1386 * This relies on T_ACI_CWUP_TYPE and T_BAT_percent_cwup_type being
1387 * identical.
1388 */
1389 cwup.type=(T_BAT_percent_cwup_type)type;
1390
1391 bat_send(ati_bat_get_client(srcId), &cmd);
1392 return(ATI_EXCT);
1393 }
1394
1395 #else /* no FF_ATI_BAT */
1396
1397 ret = sAT_PercentCWUP ((T_ACI_CMD_SRC)srcId, type);
1398
1399 switch (ret)
1400 {
1401 case (AT_CMPL): /*operation completed*/
1402 break;
1403
1404 default:
1405 cmdCmeError(CME_ERR_Unknown); /*Command failed*/
1406 break;
1407 }
1408 return (map_aci_2_ati_rslt(ret));
1409
1410 #endif /* no FF_ATI_BAT */
1411 }
1412
1413 /*
1414 +--------------------------------------------------------------------+
1415 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1416 | STATE : code ROUTINE : atPlusCIND |
1417 +--------------------------------------------------------------------+
1418
1419 PURPOSE : +CIND command
1420 (configures the signal strength and SMS full indication)
1421 */
1422 GLOBAL T_ATI_RSLT setatPlusCIND (char *cl, UBYTE srcId)
1423 {
1424 T_ACI_RETURN tRet = AT_FAIL;
1425 T_ACI_MM_CIND_VAL_TYPE sCindSettings;
1426
1427 TRACE_FUNCTION("setatPLusCIND()");
1428
1429 if (!cl)
1430 {
1431 cmdCmeError(CME_ERR_OpNotAllow);
1432 return ATI_FAIL;
1433 }
1434
1435 sCindSettings.sCindSignalParam = CIND_SIGNAL_INDICATOR_LVL0;
1436 sCindSettings.sCindSmsFullParam = CIND_SMSFULL_INDICATOR_MEMAVAIL;
1437
1438 cl = parse(cl,"dd", &sCindSettings.sCindSignalParam,
1439 &sCindSettings.sCindSmsFullParam);
1440
1441 if ((sCindSettings.sCindSignalParam < CIND_SIGNAL_INDICATOR_LVL0 OR
1442 sCindSettings.sCindSignalParam > CIND_SIGNAL_INDICATOR_LVL5) OR
1443 (sCindSettings.sCindSmsFullParam < CIND_SMSFULL_INDICATOR_MEMAVAIL OR
1444 sCindSettings.sCindSmsFullParam > CIND_SMSFULL_INDICATOR_MEMFULL))
1445 {
1446 cmdCmeError(CME_ERR_OpNotAllow);
1447 return ATI_FAIL;
1448 }
1449
1450 #ifdef FF_ATI_BAT
1451 {
1452 T_BAT_cmd_send cmd;
1453 T_BAT_cmd_set_plus_cind cind;
1454
1455 /*
1456 * Without this we will lose track of the source ID by the time the
1457 * response arrives.
1458 */
1459 srcId_cb=srcId;
1460
1461 cmd.ctrl_params = BAT_CMD_SET_PLUS_CIND;
1462 cmd.params.ptr_set_plus_cind=&cind;
1463
1464 /*
1465 * This relies on T_ACI_CIND_SIGNAL_TYPE being identical to
1466 * T_BAT_plus_cind_signal_ctrl and T_ACI_CIND_SMSFULL_TYPE being
1467 * identical to T_BAT_plus_cind_smsfull_ctrl.
1468 */
1469 cind.signal_ctrl=(T_BAT_plus_cind_signal_ctrl)sCindSettings.sCindSignalParam;
1470 cind.smsfull_ctrl=(T_BAT_plus_cind_smsfull_ctrl)sCindSettings.sCindSmsFullParam;
1471
1472 bat_send(ati_bat_get_client(srcId), &cmd);
1473 return(ATI_EXCT);
1474 }
1475 #else /* no FF_ATI_BAT */
1476
1477 tRet = sAT_PlusCIND( (T_ACI_CMD_SRC)srcId, sCindSettings.sCindSignalParam,
1478 sCindSettings.sCindSmsFullParam );
1479
1480 if (tRet EQ AT_FAIL)
1481 {
1482 cmdCmeError(CME_ERR_OpNotAllow);
1483 return ATI_FAIL;
1484 }
1485 return ATI_CMPL;
1486
1487 #endif /* no FF_ATI_BAT */
1488 }
1489
1490 /*
1491 +--------------------------------------------------------------------+
1492 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1493 | STATE : code ROUTINE : queatPlusCIND |
1494 +--------------------------------------------------------------------+
1495
1496 PURPOSE : +CIND query command
1497 (query the configured unsolicited signal strength
1498 and SMS full indication settings)
1499 */
1500 GLOBAL T_ATI_RSLT queatPlusCIND ( char *cl, UBYTE srcId )
1501 {
1502 #ifndef FF_ATI_BAT
1503 T_ACI_RETURN sRet = AT_FAIL;
1504 T_ACI_MM_CIND_VAL_TYPE sCindSettings;
1505 #endif
1506
1507 TRACE_FUNCTION("queatPlusCIND()");
1508
1509 #ifdef FF_ATI_BAT
1510 {
1511 T_BAT_cmd_send cmd;
1512 T_BAT_no_parameter dummy;
1513
1514 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CIND;
1515 dummy.bat_dummy = 0xFF;
1516 cmd.params.ptr_que_plus_cind = &dummy;
1517 bat_send(ati_bat_get_client(srcId), &cmd);
1518 return(ATI_EXCT);
1519 }
1520 #else /* no FF_ATI_BAT */
1521
1522 sRet = qAT_PlusCIND( (T_ACI_CMD_SRC)srcId, &sCindSettings.sCindSignalParam,
1523 &sCindSettings.sCindSmsFullParam );
1524
1525 if ( sCindSettings.sCindSignalParam EQ CIND_SIGNAL_INDICATOR_INVALID ) { sCindSettings.sCindSignalParam = CIND_SIGNAL_INDICATOR_LVL0; }
1526 if ( sCindSettings.sCindSmsFullParam EQ CIND_SMSFULL_INDICATOR_INVALID ) { sCindSettings.sCindSmsFullParam = CIND_SMSFULL_INDICATOR_MEMAVAIL; }
1527
1528 if (sRet EQ AT_CMPL)
1529 {
1530 resp_disp( srcId, cl,"ee", &sCindSettings.sCindSignalParam,
1531 &sCindSettings.sCindSmsFullParam );
1532 return ATI_CMPL;
1533 }
1534 else
1535 { /* error case */
1536 cmdCmeError(CME_ERR_OpNotAllow);
1537 return ATI_FAIL;
1538 }
1539
1540 #endif /* no FF_ATI_BAT */
1541 }
1542
1543 /*
1544 +--------------------------------------------------------------------+
1545 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1546 | STATE : code ROUTINE : atPlusCMER |
1547 +--------------------------------------------------------------------+
1548
1549 PURPOSE : +CMER command
1550 (configures the kind of indication handling toward terminal)
1551 */
1552 GLOBAL T_ATI_RSLT setatPlusCMER ( char *cl, UBYTE srcId )
1553 {
1554 /* UINT uiBufferCounter; */
1555 T_ACI_RETURN tRet = AT_FAIL;
1556 T_ACI_MM_CMER_VAL_TYPE sCmerSettings;
1557 T_ACI_MM_CMER_VAL_TYPE sOldCmerSettings;
1558 T_ACI_MM_CMER_VAL_TYPE sEnteredCmerSettings;
1559 UINT uiDummy1 = 0u;
1560 UINT uiDummy2 = 0u;
1561
1562 TRACE_FUNCTION("setatPLusCMER()");
1563
1564 if (!cl)
1565 {
1566 cmdCmeError(CME_ERR_OpNotAllow);
1567 return ATI_FAIL;
1568 }
1569
1570 sCmerSettings.sCmerModeParam = CMER_MODE_INVALID;
1571 sCmerSettings.sCmerIndParam = CMER_INDICATOR_INVALID;
1572 sCmerSettings.sCmerBfrParam = CMER_BFR_INVALID;
1573
1574 cl = parse(cl,"ddddd", &sCmerSettings.sCmerModeParam,
1575 &uiDummy1,
1576 &uiDummy2,
1577 &sCmerSettings.sCmerIndParam,
1578 &sCmerSettings.sCmerBfrParam );
1579
1580 if ((sCmerSettings.sCmerModeParam < CMER_MODE_INVALID OR
1581 sCmerSettings.sCmerModeParam > CMER_MODE_2) OR
1582 (sCmerSettings.sCmerIndParam < CMER_INDICATOR_INVALID OR
1583 sCmerSettings.sCmerIndParam > CMER_INDICATOR_2) OR
1584 (sCmerSettings.sCmerBfrParam < CMER_BFR_INVALID OR
1585 sCmerSettings.sCmerBfrParam > CMER_BFR_1) OR
1586 (uiDummy1 NEQ 0u) OR ((uiDummy2 NEQ 0u)))
1587 {
1588 cmdCmeError(CME_ERR_OpNotAllow);
1589 return ATI_FAIL;
1590 }
1591
1592 cmhMM_GetCmerSettings( (T_ACI_CMD_SRC)srcId, &sOldCmerSettings );
1593
1594 sEnteredCmerSettings.sCmerModeParam = sCmerSettings.sCmerModeParam;
1595
1596 #ifdef FF_ATI_BAT
1597 {
1598 T_BAT_cmd_send cmd;
1599 T_BAT_cmd_set_plus_cmer cmer;
1600
1601 /*
1602 * Without this we will lose track of the source ID by the time the
1603 * response arrives.
1604 */
1605 srcId_cb=srcId;
1606
1607 cmd.ctrl_params = BAT_CMD_SET_PLUS_CMER;
1608 cmd.params.ptr_set_plus_cmer=&cmer;
1609
1610 cmer.ind_option=BAT_CMER_IND_OPTION_NOT_PRESENT;
1611
1612 bat_send(ati_bat_get_client(srcId), &cmd);
1613 return(ATI_EXCT);
1614 }
1615 #else /* no FF_ATI_BAT */
1616
1617 tRet = sAT_PlusCMER((T_ACI_CMD_SRC)srcId, sCmerSettings.sCmerModeParam,
1618 sCmerSettings.sCmerIndParam,
1619 sCmerSettings.sCmerBfrParam );
1620 if (tRet EQ AT_FAIL)
1621 {
1622 cmdCmeError(CME_ERR_OpNotAllow);
1623 return ATI_FAIL;
1624 }
1625
1626 if ( sCmerSettings.sCmerModeParam EQ CMER_MODE_INVALID ) { sCmerSettings.sCmerModeParam = sOldCmerSettings.sCmerModeParam; }
1627 if ( sCmerSettings.sCmerIndParam EQ CMER_INDICATOR_INVALID ) { sCmerSettings.sCmerIndParam = sOldCmerSettings.sCmerIndParam; }
1628 if ( sCmerSettings.sCmerBfrParam EQ CMER_BFR_INVALID ) { sCmerSettings.sCmerBfrParam = sOldCmerSettings.sCmerBfrParam; }
1629 if ( sCmerSettings.sCmerIndParam EQ CMER_INDICATOR_INVALID ) { sCmerSettings.sCmerIndParam = CMER_INDICATOR_0; }
1630 if ( sCmerSettings.sCmerBfrParam EQ CMER_BFR_INVALID ) { sCmerSettings.sCmerBfrParam = CMER_BFR_0; }
1631
1632 switch( sCmerSettings.sCmerModeParam )
1633 {
1634 case CMER_MODE_INVALID :
1635 case CMER_MODE_0 :
1636 { /* always buffer --> do nothing */
1637 break;
1638 }
1639 case CMER_MODE_1 :
1640 case CMER_MODE_2 :
1641 { /* flush and/or clear buffer */
1642 if ( (sEnteredCmerSettings.sCmerModeParam EQ CMER_MODE_1) OR
1643 (sEnteredCmerSettings.sCmerModeParam EQ CMER_MODE_2) )
1644 {
1645 if ( sCmerSettings.sCmerBfrParam EQ CMER_BFR_0 )
1646 {
1647 cmd_clearCievBuf( srcId );
1648 }
1649 else
1650 { /* BFR == '2' */
1651 cmd_flushCievBuf( srcId );
1652 }
1653
1654 }
1655 break;
1656 }
1657 default :
1658 { /* error case */
1659 cmdCmeError(CME_ERR_OpNotAllow);
1660 return ATI_FAIL;
1661 }
1662 }
1663 return ATI_CMPL;
1664
1665 #endif /* no FF_ATI_BAT */
1666 }
1667
1668 /*
1669 +--------------------------------------------------------------------+
1670 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1671 | STATE : code ROUTINE : queatPlusCMER |
1672 +--------------------------------------------------------------------+
1673
1674 PURPOSE : +CMER query command
1675 (query the configured indication handling settings
1676 toward terminal )
1677 */
1678 GLOBAL T_ATI_RSLT queatPlusCMER ( char *cl, UBYTE srcId )
1679 {
1680 #ifndef FF_ATI_BAT
1681 T_ACI_RETURN sRet = AT_FAIL;
1682 T_ACI_MM_CMER_VAL_TYPE sCmerSettings;
1683 UINT uiDummy = 0u;
1684 #endif
1685
1686 TRACE_FUNCTION("queatPLusCMER()");
1687
1688 #ifdef FF_ATI_BAT
1689 {
1690 T_BAT_cmd_send cmd;
1691 T_BAT_no_parameter dummy;
1692
1693 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CMER;
1694 dummy.bat_dummy = 0xFF;
1695 cmd.params.ptr_que_plus_cmer = &dummy;
1696 bat_send(ati_bat_get_client(srcId), &cmd);
1697 return(ATI_EXCT);
1698 }
1699 #else /* no FF_ATI_BAT */
1700
1701 sRet = qAT_PlusCMER( (T_ACI_CMD_SRC)srcId, &sCmerSettings.sCmerModeParam,
1702 &sCmerSettings.sCmerIndParam,
1703 &sCmerSettings.sCmerBfrParam );
1704
1705 if (sRet NEQ AT_CMPL)
1706 {
1707 cmdCmeError(CME_ERR_OpNotAllow);
1708 return ATI_FAIL;
1709 }
1710
1711 if ( sCmerSettings.sCmerModeParam EQ CMER_MODE_INVALID ) { sCmerSettings.sCmerModeParam = CMER_MODE_0; };
1712 if ( sCmerSettings.sCmerIndParam EQ CMER_INDICATOR_INVALID ) { sCmerSettings.sCmerIndParam = CMER_INDICATOR_0; };
1713 if ( sCmerSettings.sCmerBfrParam EQ CMER_BFR_INVALID ) { sCmerSettings.sCmerBfrParam = CMER_BFR_0; };
1714
1715 resp_disp( srcId, cl,"eeeee",&sCmerSettings.sCmerModeParam,
1716 &uiDummy,
1717 &uiDummy,
1718 &sCmerSettings.sCmerIndParam,
1719 &sCmerSettings.sCmerBfrParam );
1720 return ATI_CMPL;
1721
1722 #endif /* no FF_ATI_BAT */
1723 }
1724
1725 /*
1726 +--------------------------------------------------------------------+
1727 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1728 | STATE : code ROUTINE : cmd_flushCievBuf |
1729 +--------------------------------------------------------------------+
1730
1731 PURPOSE : This function flushes the buffer for storing new signal-
1732 and/or SMS-full indications while the serial interface is
1733 released from data transmission.
1734 */
1735 GLOBAL void cmd_flushCievBuf ( UBYTE srcId )
1736 {
1737 UINT uiBufferCounter;
1738 UINT uiTempLastIndex;
1739 T_ACI_MM_CIND_VAL_TYPE sCindValues;
1740 T_ACI_MM_CMER_VAL_TYPE sCmerSettings;
1741
1742 TRACE_FUNCTION("cmd_flushCievBuf");
1743
1744 /* Signal buffer */
1745 uiTempLastIndex = asCievSignalBuf.uiLastIndex;
1746 cmhMM_GetCmerSettings((T_ACI_CMD_SRC)srcId, &sCmerSettings);
1747 for( uiBufferCounter=0; uiBufferCounter < uiTempLastIndex; uiBufferCounter++ )
1748 {
1749 sCindValues.sCindSignalParam = asCievSignalBuf.asBufferValues[uiBufferCounter];
1750 sCindValues.sCindSmsFullParam = CIND_SMSFULL_INDICATOR_INVALID;
1751 rCI_PlusCIEV( sCindValues, sCmerSettings );
1752 asCievSignalBuf.asBufferValues[uiBufferCounter] = CIND_SIGNAL_INDICATOR_INVALID;
1753 asCievSignalBuf.uiLastIndex--;
1754 }
1755
1756 /* SMS Full buffer */
1757 uiTempLastIndex = asCievSmsFullBuf.uiLastIndex;
1758 for( uiBufferCounter=0; uiBufferCounter < uiTempLastIndex; uiBufferCounter++ )
1759 {
1760 sCindValues.sCindSmsFullParam = asCievSmsFullBuf.asBufferValues[uiBufferCounter];
1761 sCindValues.sCindSignalParam = CIND_SIGNAL_INDICATOR_INVALID;
1762 rCI_PlusCIEV( sCindValues, sCmerSettings );
1763 asCievSmsFullBuf.asBufferValues[uiBufferCounter] = CIND_SMSFULL_INDICATOR_INVALID;
1764 asCievSmsFullBuf.uiLastIndex--;
1765 }
1766 }
1767
1768 /*
1769 +--------------------------------------------------------------------+
1770 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1771 | STATE : code ROUTINE : cmd_clearCievBuf |
1772 +--------------------------------------------------------------------+
1773
1774 PURPOSE : This function clear the buffer for storing new signal-
1775 and/or SMS-full indications
1776 */
1777 GLOBAL void cmd_clearCievBuf ( UBYTE srcId )
1778 {
1779 UBYTE tSrc;
1780
1781 for( tSrc=0; tSrc < CIEV_BUF_SIZE; tSrc++ )
1782 {
1783 asCievSignalBuf.asBufferValues[tSrc] = CIND_SIGNAL_INDICATOR_INVALID;
1784 asCievSmsFullBuf.asBufferValues[tSrc] = CIND_SMSFULL_INDICATOR_INVALID;
1785 }
1786 asCievSignalBuf.uiLastIndex = 0u;
1787 asCievSmsFullBuf.uiLastIndex = 0u;
1788 }
1789
1790 /*
1791 +--------------------------------------------------------------------+
1792 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1793 | STATE : code ROUTINE : cmd_PlusCOPN_CB |
1794 +--------------------------------------------------------------------+
1795
1796 PURPOSE : Call back function for cmd_PlusCOPN_CB
1797 */
1798
1799 GLOBAL void cmd_PlusCOPN_CB ( UBYTE src_id )
1800 {
1801 SHORT startIdx;
1802 UBYTE curCmd;
1803 T_ATI_SRC_PARAMS *src_params;
1804 T_COPN_VAR *COPN_Var;
1805 BOOL ret;
1806
1807
1808 COPN_Var = &mmShrdPrm.COPN_VAR[src_id];
1809
1810
1811 startIdx = COPN_Var->Start_Count;
1812
1813
1814 TRACE_FUNCTION("cmd_PlusCOPN_CB()");
1815
1816 ret = cmd_readCOPNBlock(startIdx,src_id);
1817
1818 if (ret EQ TRUE)
1819 {
1820 src_params = find_element (ati_src_list, src_id, search_ati_src_id);
1821 curCmd = src_params->curAtCmd;
1822 R_AT( RAT_OK, (T_ACI_CMD_SRC)src_id )
1823 ( curCmd );
1824 }
1825 }
1826
1827 GLOBAL BOOL cmd_readCOPNBlock( SHORT startIdx, UBYTE src_id )
1828 {
1829 SHORT lastIdx;
1830 UBYTE idx;
1831 T_ACI_COPN_LST operLst;
1832 T_COPN_VAR *COPN_Var;
1833
1834 COPN_Var = &mmShrdPrm.COPN_VAR[src_id];
1835
1836 TRACE_FUNCTION("cmd_readCOPNBlock()");
1837
1838 if( qAT_PlusCOPN((T_ACI_CMD_SRC)src_id, COPN_LID_Cnst, startIdx,
1839 &lastIdx, operLst) EQ AT_FAIL )
1840 return TRUE;
1841
1842 for( idx=0; idx < MAX_OPER; idx++ )
1843 {
1844 if( operLst[idx].numOper[0] EQ 0x0 )
1845 return TRUE;
1846
1847 sprintf(g_sa,"+COPN: \"%s\",\"%s\"",operLst[idx].numOper,
1848 operLst[idx].alphaOper );
1849 io_sendMessage(src_id, g_sa, ATI_NORMAL_OUTPUT);
1850 }
1851 startIdx = lastIdx+1;
1852 COPN_Var->Start_Count = startIdx;
1853 return FALSE;
1854 }
1855
1856
1857 #endif /* ATI_MM_C */