FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/ati_cc.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: Call Control related commands.
18 +-----------------------------------------------------------------------------
19 */
20 #ifndef ATI_CC_C
21 #define ATI_CC_C
22
23 #include "config.h"
24 #include "fixedconf.h"
25 #include "condat-features.h"
26 #include "aci_conf.h"
27
28 #undef DUMMY_ATI_STRINGS
29
30 #include "aci_all.h"
31
32 #include "aci_cmh.h"
33 #include "ati_cmd.h"
34 #include "aci_io.h"
35 #include "aci_cmd.h"
36 #include "l4_tim.h"
37 #include "aci_lst.h"
38
39 #include "aci_cmh.h"
40 #include "ati_cmd.h"
41 #include "aci_io.h"
42 #include "aci_cmd.h"
43
44 #include "aci.h"
45 #include "l4_tim.h"
46 #include "aci_mem.h"
47 #include "aci_prs.h"
48
49 #include "aci_lst.h"
50 #include "ati_int.h"
51
52 #ifdef FF_ATI_BAT
53
54 #include "typedefs.h"
55 #include "gdd.h"
56 #include "bat.h"
57
58 #include "ati_bat.h"
59
60 #endif /* FF_ATI_BAT */
61
62 /*
63 +--------------------------------------------------------------------+
64 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
65 | STATE : code ROUTINE : cleanDialStr |
66 +--------------------------------------------------------------------+
67
68 PURPOSE : This function removes all invalid or unsupported characters
69 from the null terminated dial string.
70
71 */
72
73 LOCAL void cleanDialStr( CHAR * dialStr )
74 {
75 USHORT i,j,k = 0;
76 USHORT dialLen, charLen;
77 CHAR *valChrs = "0123456789*#+-ABCDPpWw";
78 UBYTE match = FALSE;
79
80 dialLen = strlen(dialStr );
81 charLen = strlen(valChrs );
82
83 for (i=0;i<dialLen;i++)
84 {
85 match=FALSE;
86
87 for (j=0;j<charLen;j++)
88 {
89 if (dialStr[i] EQ valChrs[j])
90 {
91 match = TRUE;
92 break;
93 }
94 }
95
96 if (match)
97 {
98 dialStr[k] = dialStr[i];
99 k++;
100 }
101 }
102
103 dialStr[k] = 0x0;
104 }
105
106 /*
107 +--------------------------------------------------------------------+
108 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
109 | STATE : code ROUTINE : |
110 +--------------------------------------------------------------------+
111
112 PURPOSE : D (dial command)
113 */
114
115 #define NAME_BUF_LEN 32
116 #define DIAL_BUF_LEN (MAX_DIAL_LEN-1)
117
118 GLOBAL T_ATI_RSLT atD (char *cl, UBYTE srcId)
119 {
120 T_ACI_RETURN ret = AT_FAIL;
121 char alpha [NAME_BUF_LEN] = {'\0'};
122 USHORT lenAlpha = 0;
123 char cvtdAlpha[NAME_BUF_LEN] = {'\0'};
124 USHORT lenCvtdAlpha = 0;
125 char t [DIAL_BUF_LEN] = {'\0'};
126 char* t_p = NULL;
127 USHORT pos = 0;
128 SHORT index = -1;
129
130 T_ACI_PB_STOR mem_stor = PB_STOR_NotPresent;
131 T_ACI_D_CLIR_OVRD clir_ovrd = D_CLIR_OVRD_Default;
132 T_ACI_D_CUG_CTRL cug_ctrl = D_CUG_CTRL_NotPresent;
133 T_ACI_D_TOC call_type = D_TOC_Data;
134 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
135
136 src_params->curAtCmd = AT_CMD_D;
137
138 #ifdef FF_ATI_BAT
139 {
140 T_BAT_cmd_send cmd;
141 T_BAT_cmd_at_d bat_dial;
142
143 cmd.ctrl_params = BAT_CMD_AT_D;
144 cmd.params.ptr_at_d = &bat_dial;
145
146 #warning "atD(): check for UCS2 dial string before bat_send()"
147
148 bat_dial.c_dial_string = strlen(cl);
149 if (bat_dial.c_dial_string)
150 {
151 memcpy (bat_dial.dial_string, (U8 *)cl, bat_dial.c_dial_string);
152
153 TRACE_FUNCTION("atD() calls bat_send() <=== as APPLICATION");
154
155 bat_send(ati_bat_get_client(srcId), &cmd);
156 cmdErrStr = NULL;
157 srcId_cb = srcId;
158 rCI_PlusCCWV (CCWV_CHRG_NotPresent);
159 return (ATI_EXCT); /* executing, because response is passed by callback function */
160 }
161 else
162 {
163 cmdCmeError(CME_ERR_OpNotAllow);
164 return (ATI_FAIL);
165 }
166 }
167 #else /* no FF_ATI_BAT */
168 {
169 BOOL Book_Dial;
170 U16 i;
171 #ifdef NO_ASCIIZ
172 T_ACI_PB_TEXT pbText;
173 #endif
174
175 TRACE_FUNCTION("atD()");
176
177 t_p=t;
178 if (*cl EQ '>') /*call from Phonebook*/
179 {
180 Book_Dial=TRUE;
181 cl++;
182 if(*cl EQ '"') /*origin call to name given by string */
183 {
184 cl=parse(cl,"z",
185 (LONG)NAME_BUF_LEN,
186 strlen(cl),
187 cl,
188 &lenAlpha,
189 alpha);
190 if (cl EQ NULL)
191 {
192 cmdCmeError(CME_ERR_OpNotAllow);
193 return (ATI_FAIL);
194 }
195 else if (strcspn(cl,"iIgG;") NEQ 0)
196 {
197 cmdCmeError(CME_ERR_OpNotAllow);
198 return (ATI_FAIL);
199 }
200 srcId_cb = srcId;
201 #ifdef NO_ASCIIZ
202 utl_chsetToSim ( (UBYTE*)alpha,
203 lenAlpha,
204 (UBYTE*)cvtdAlpha,
205 &lenCvtdAlpha,
206 GSM_ALPHA_Def );
207 #else /* #ifdef NO_ASCIIZ */
208 utl_chsetToGsm ( (UBYTE*)alpha,
209 lenAlpha,
210 (UBYTE*)cvtdAlpha,
211 &lenCvtdAlpha,
212 #ifdef REL99
213 sizeof(cvtdAlpha),
214 #endif
215 GSM_ALPHA_Int);
216 #endif /* #ifdef NO_ASCIIZ */
217 t_p = cvtdAlpha;
218 }
219 else
220 {
221 /* call using phonebook with pb specified*/
222 if ((toupper(*cl)) >= 65 AND (toupper(*cl)) <= 90)
223 {
224 for (i=0;phb_mem_names[i].name != 0;i++)
225 {
226 strupper(cl);
227 if (strncmp(cl,phb_mem_names[i].name,2) EQ 0)
228 {
229 mem_stor=phb_mem_names[i].stor;
230 break;
231 }
232 else mem_stor=PB_STOR_NotPresent;
233 }
234 if (mem_stor < 0)
235 {
236 cmdCmeError(CME_ERR_OpNotAllow);
237 return (ATI_FAIL);
238 }
239 cl=cl+2;
240 }
241 pos=strcspn(cl,"iIgG;"); /* determine index */
242 if (pos EQ 0 OR pos >= DIAL_BUF_LEN)
243 {
244 TRACE_EVENT("incorrect strspn");
245 cmdCmeError(CME_ERR_OpNotAllow);
246 return (ATI_FAIL);
247 }
248 strncpy(t,cl,pos);
249 cl=cl+pos;
250 index =(SHORT)atoi(t);
251
252 if(!index OR index > 300)
253 {
254 cmdCmeError(CME_ERR_OpNotAllow);
255 return (ATI_FAIL);
256 }
257 t_p = NULL;
258 }
259 }
260 else
261 {
262 Book_Dial=FALSE;
263 pos=strcspn(cl,"iIgG;");
264 if(pos >= DIAL_BUF_LEN)
265 {
266 cmdCmeError(CME_ERR_OpNotAllow);
267 return (ATI_FAIL);
268 }
269 if (pos)
270 {
271 strncpy(t,cl,pos);
272 cl=cl+pos;
273 t[pos]='\0';
274 }
275 else
276 {
277 if(strlen(cl) >= DIAL_BUF_LEN)
278 {
279 cmdCmeError(CME_ERR_OpNotAllow);
280 return (ATI_FAIL);
281 }
282 strcpy(t,cl);
283 }
284
285 cleanDialStr(t);
286 if (t[0] EQ '\0')
287 t_p=NULL;
288 }
289
290 if (*cl EQ 'i')
291 {
292 clir_ovrd=D_CLIR_OVRD_Supp;
293 cl++;
294 }
295 if (*cl EQ 'I')
296 {
297 clir_ovrd=D_CLIR_OVRD_Invoc;
298 cl++;
299 }
300 if (*cl EQ 'g'OR *cl EQ 'G')
301 {
302 cug_ctrl=D_CUG_CTRL_Present;
303 cl++;
304 }
305 if (*cl EQ ';')
306 {
307 call_type=D_TOC_Voice;
308 cl++;
309 }
310 if (*cl NEQ '\0')
311 {
312 cmdCmeError(CME_ERR_InvDialChar);
313 return (ATI_FAIL);
314 }
315
316 if(Book_Dial)
317 {
318 #ifdef NO_ASCIIZ
319 if ( t_p NEQ NULL )
320 {
321 pbText.cs = CS_Sim;
322 pbText.len = (UBYTE)lenCvtdAlpha;
323 memcpy( pbText.data, t_p, pbText.len );
324 }
325 else
326 {
327 pbText.cs = CS_NotPresent;
328 pbText.len = 0;
329 }
330 ret = sAT_Dm( (T_ACI_CMD_SRC)srcId, &pbText, mem_stor, index, clir_ovrd,
331 cug_ctrl, call_type );
332 #else /* #ifdef NO_ASCIIZ */
333 ret = sAT_Dm( srcId, t_p, mem_stor, index, clir_ovrd,
334 cug_ctrl, call_type );
335 #endif /* #ifdef NO_ASCIIZ */
336 }
337 else
338 {
339 ret=sAT_Dn((T_ACI_CMD_SRC)srcId,t_p,clir_ovrd,cug_ctrl,call_type);
340 }
341
342 if (ret EQ AT_EXCT)
343 {
344 if (call_type EQ D_TOC_Voice AND
345 at.flags.COLP_stat NEQ 1 )
346 {
347 cmdErrStr = NULL;
348 }
349 else
350 {
351 src_params->curAtCmd = AT_CMD_D;
352 }
353 srcId_cb = srcId;
354 rCI_PlusCCWV ( CCWV_CHRG_NotPresent );
355
356 return (ATI_EXCT);
357 }
358 else if( ret EQ AT_CMPL )
359 {
360 srcId_cb = srcId;
361 rCI_OK (AT_CMD_D);
362 return (ATI_CMPL_NO_OUTPUT);
363 }
364 else
365 {
366 cmdCmeError(CME_ERR_Unknown);
367 return (ATI_FAIL);
368 }
369 }
370 #endif /* no FF_ATI_BAT */
371 }
372
373
374 /*
375 +--------------------------------------------------------------------+
376 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
377 | STATE : code ROUTINE : atA |
378 +--------------------------------------------------------------------+
379
380 PURPOSE : A command (Answer a call)
381 */
382
383 GLOBAL T_ATI_RSLT atA(char *cl, UBYTE srcId)
384 {
385 T_ACI_RETURN ret = AT_FAIL;
386 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
387
388 #ifdef FF_ATI_BAT
389 T_BAT_cmd_send cmd;
390 T_BAT_no_parameter dummy;
391
392 TRACE_FUNCTION("atA() calls bat_send() <=== as APPLICATION");
393
394 cmd.ctrl_params = BAT_CMD_AT_A;
395 dummy.bat_dummy = 0xFF;
396 cmd.params.ptr_at_a = &dummy;
397
398 if( at.rngPrms.isRng EQ TRUE )
399 {
400 ati_stop_ring();
401 }
402 src_params->curAtCmd = AT_CMD_A;
403
404 bat_send(ati_bat_get_client(srcId), &cmd);
405
406 return (ATI_EXCT); /* executing, because response is passed by callback function */
407
408 #else /* no FF_ATI_BAT */
409
410 TRACE_FUNCTION("atA()");
411
412 if(*cl NEQ '\0')
413 {
414 cmdAtError(atError);
415 }
416 else
417 {
418 ret=sAT_A((T_ACI_CMD_SRC)srcId);
419 if (ret EQ AT_EXCT)
420 {
421 if( at.rngPrms.isRng EQ TRUE )
422 {
423 ati_stop_ring();
424 }
425 src_params->curAtCmd = AT_CMD_A;
426 }
427 else
428 {
429 cmdAtError(atError);
430 }
431 }
432 return (map_aci_2_ati_rslt(ret));
433
434 #endif /* no FF_ATI_BAT */
435 }
436
437 /*
438 +--------------------------------------------------------------------+
439 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
440 | STATE : code ROUTINE : atH |
441 +--------------------------------------------------------------------+
442
443 PURPOSE : H command (Hangs up single mode call)
444 */
445 GLOBAL T_ATI_RSLT atH(char *cl, UBYTE srcId)
446 {
447 T_ACI_RETURN ret = AT_FAIL;
448 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
449
450 #ifdef FF_ATI_BAT
451 T_BAT_cmd_send cmd;
452 T_BAT_no_parameter dummy;
453 cmd.ctrl_params = BAT_CMD_AT_H;
454 dummy.bat_dummy = 0xFF;
455 cmd.params.ptr_at_h = &dummy;
456
457 TRACE_FUNCTION("atH() calls bat_send() <=== as APPLICATION");
458
459 if( at.rngPrms.isRng EQ TRUE )
460 {
461 ati_stop_ring();
462 }
463 src_params->curAtCmd = AT_CMD_H;
464
465 bat_send(ati_bat_get_client(srcId), &cmd);
466
467 return (ATI_EXCT); /* executing, because response is passed by callback function */
468 #else /* no FF_ATI_BAT */
469
470 TRACE_FUNCTION("atH()");
471
472 if (*cl EQ '0' OR *cl EQ '\0')
473 {
474 if (*cl EQ '0')
475 {
476 cl++;
477 }
478
479 ret=sAT_H((T_ACI_CMD_SRC)srcId);
480 if (ret EQ AT_EXCT)
481 {
482 if( at.rngPrms.isRng EQ TRUE )
483 {
484 ati_stop_ring();
485 }
486 src_params->curAtCmd = AT_CMD_H;
487 }
488 else
489 {
490 cmdAtError(atError);
491 }
492 }
493 else
494 {
495 cmdAtError(atError);
496 }
497 return (map_aci_2_ati_rslt(ret));
498
499 #endif /* no FF_ATI_BAT */
500 }
501
502 #ifdef FAX_AND_DATA
503 /*
504 +--------------------------------------------------------------------+
505 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
506 | STATE : code ROUTINE : atPlusCBST |
507 +--------------------------------------------------------------------+
508
509 PURPOSE : +CBST command (Select Bearer Service Type)
510 */
511
512 GLOBAL T_ATI_RSLT setatPlusCBST(char *cl, UBYTE srcId)
513 {
514 T_ACI_BS_SPEED speed = BS_SPEED_NotPresent;
515 T_ACI_CBST_NAM name = CBST_NAM_NotPresent;
516 T_ACI_CBST_CE ce = CBST_CE_NotPresent;
517 T_ACI_RETURN ret = AT_FAIL;
518
519 cl = parse(cl, "ddd", &speed, &name, &ce);
520 if(!cl )
521 {
522 cmdCmeError(CME_ERR_OpNotAllow);
523 return (ATI_FAIL);
524 }
525
526 #ifdef FF_ATI_BAT
527 {
528 T_BAT_cmd_send cmd;
529 T_BAT_cmd_set_plus_cbst my_bat_set_plus_cbst;
530
531 TRACE_FUNCTION("setatPlusCBST() calls bat_send() <=== as APPLICATION");
532
533 memset(&my_bat_set_plus_cbst, 0, sizeof(my_bat_set_plus_cbst));
534 cmd.ctrl_params = BAT_CMD_SET_PLUS_CBST;
535 cmd.params.ptr_set_plus_cbst = &my_bat_set_plus_cbst;
536
537 my_bat_set_plus_cbst.speed = speed;
538 my_bat_set_plus_cbst.name = name;
539 my_bat_set_plus_cbst.ce = ce;
540 bat_send(ati_bat_get_client(srcId), &cmd);
541
542 return ATI_EXCT; /* executing, because response is passed by callback function */
543 }
544 #else /* OLD FUNCTION BODY */
545
546 TRACE_FUNCTION("atPLusCBST()");
547 {
548 ret = sAT_PlusCBST((T_ACI_CMD_SRC)srcId,speed,name,ce);
549 }
550 if (ret EQ AT_FAIL)
551 {
552 cmdCmeError(CME_ERR_OpNotAllow);
553 return (ATI_FAIL);
554 }
555 return (ATI_CMPL);
556
557 #endif /* no FF_ATI_BAT*/
558 }
559
560 GLOBAL T_ATI_RSLT queatPlusCBST(char *cl, UBYTE srcId)
561 {
562 T_ACI_BS_SPEED speed = BS_SPEED_NotPresent;
563 T_ACI_CBST_NAM name = CBST_NAM_NotPresent;
564 T_ACI_CBST_CE ce = CBST_CE_NotPresent;
565 T_ACI_RETURN ret = AT_FAIL;
566
567 TRACE_FUNCTION("atPLusCBST()");
568
569 ret = qAT_PlusCBST((T_ACI_CMD_SRC)srcId,&speed,&name,&ce);
570 if (ret EQ AT_CMPL)
571 {
572 resp_disp(srcId, cl,"eee",&speed,&name,&ce);
573 }
574 else
575 {
576 cmdCmeError(CME_ERR_OpNotAllow); /* AT_FAIL, AT_EXCT, AT_BUSY ??? */
577 return (ATI_FAIL);
578 }
579 return (ATI_CMPL);
580
581 }
582 #endif /* FAX_AND_DATA */
583
584 /*
585 PURPOSE : Change some AT interface output configuration
586 (+CRC +CR +CLIP +COLP)
587 */
588 GLOBAL T_ATI_RSLT GenAtCR_C( CHAR *cl, UBYTE srcId, T_ACI_AT_CMD cmd )
589 {
590 UBYTE x = 0;
591
592 switch(*cl)
593 {
594 case('0'):
595 case('1'):
596 /* value ok */
597 break;
598 default:
599 cmdCmeError(CME_ERR_OpNotAllow);
600 return (ATI_FAIL);
601 }
602
603 x = *cl - '0';
604 cl++;
605
606 switch(cmd)
607 {
608 case( AT_CMD_CRC ):
609 ati_user_output_cfg[srcId].CRC_stat = x;
610 return (ATI_CMPL);
611 case( AT_CMD_CR ):
612 ati_user_output_cfg[srcId].CR_stat = x;
613 return (ATI_CMPL);
614 case( AT_CMD_CLIP ):
615 ati_user_output_cfg[srcId].CLIP_stat = x;
616 return (ATI_CMPL);
617 case( AT_CMD_CDIP ):
618 ati_user_output_cfg[srcId].CDIP_stat = x;
619 return (ATI_CMPL);
620 case( AT_CMD_COLP ):
621 at.flags.COLP_stat = x;
622 return (ATI_CMPL);
623 }
624
625 cmdCmeError(CME_ERR_OpNotAllow);
626 return (ATI_FAIL);
627 }
628
629 #ifdef FF_TTY
630 /*
631 +--------------------------------------------------------------------+
632 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
633 | STATE : code ROUTINE : atPercentCTTY |
634 +--------------------------------------------------------------------+
635
636 PURPOSE : %CTTY command (handle CTM/TTY service)
637 */
638
639 GLOBAL T_ATI_RSLT setatPercentCTTY (char *cl, UBYTE srcId)
640 {
641 T_ACI_CTTY_MOD mode = CTTY_MOD_NotPresent;
642 T_ACI_CTTY_REQ req = CTTY_REQ_NotPresent;
643
644 cl = parse (cl, "dd", &mode, &req);
645
646 if (!cl)
647 {
648 cmdCmeError(CME_ERR_OpNotAllow);
649 return (ATI_FAIL);
650 }
651
652 #ifdef FF_ATI_BAT
653 {
654 T_BAT_cmd_send cmd;
655 T_BAT_cmd_set_percent_ctty my_bat_set_percent_ctty;
656
657 TRACE_FUNCTION("setatPercentCTTY() calls bat_send() <=== as APPLICATION");
658
659 memset(&my_bat_set_percent_ctty, 0, sizeof(my_bat_set_percent_ctty));
660 cmd.ctrl_params = BAT_CMD_SET_PERCENT_CTTY;
661 cmd.params.ptr_set_percent_ctty = &my_bat_set_percent_ctty;
662
663 my_bat_set_percent_ctty.req = req;
664
665 bat_send(ati_bat_get_client(srcId), &cmd);
666
667 return ATI_EXCT; /* executing, because response is passed by callback function */
668 }
669 #else /* OLD FUNCTION BODY */
670 {
671 T_ACI_RETURN ret;
672
673 TRACE_FUNCTION("setatPercentCTTY()");
674
675 ret = sAT_PercentCTTY ((T_ACI_CMD_SRC)srcId, mode, req);
676 switch (ret)
677 {
678 case (AT_CMPL): /* operation completed */
679 break;
680 case (AT_EXCT): /* not valid */
681 ret = AT_CMPL;
682 break;
683 default:
684 cmdCmeError(CME_ERR_NotPresent); /* Command failed */
685 break;
686 }
687 return (map_aci_2_ati_rslt(ret));
688 }
689 #endif /* no FF_ATI_BAT*/
690 }
691
692 GLOBAL T_ATI_RSLT queatPercentCTTY (char *cl, UBYTE srcId)
693 {
694 T_ACI_RETURN ret;
695 T_ACI_CTTY_MOD mode;
696 T_ACI_CTTY_REQ req;
697 T_ACI_CTTY_STAT state;
698 T_ACI_CTTY_TRX trx;
699
700 TRACE_FUNCTION("queatPercentCTTY()");
701
702 ret = qAT_PercentCTTY ((T_ACI_CMD_SRC)srcId, &mode, &req, &state, &trx);
703
704 if (ret EQ AT_CMPL)
705 {
706 if (trx EQ CTTY_TRX_Unknown)
707 resp_disp (srcId, cl,"eee",&mode, &req, &state);
708 else
709 resp_disp (srcId, cl,"eeee",&mode, &req, &state, &trx);
710 return ATI_CMPL;
711 }
712 else
713 cmdCmeError (CME_ERR_Unknown);
714
715 return ATI_FAIL;
716 }
717 #endif /* FF_TTY */
718
719 /*
720 +--------------------------------------------------------------------+
721 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
722 | STATE : code ROUTINE : atPlusCRC |
723 +--------------------------------------------------------------------+
724
725 PURPOSE : +CRC command (Select extended incoming call report)
726 */
727
728 GLOBAL T_ATI_RSLT setatPlusCRC (char *cl, UBYTE srcId)
729 {
730 TRACE_FUNCTION("setatPlusCRC()");
731
732 return(GenAtCR_C( cl, srcId, AT_CMD_CRC ));
733 }
734
735 GLOBAL T_ATI_RSLT queatPlusCRC (char *cl, UBYTE srcId)
736 {
737 TRACE_FUNCTION("queatPlusCRC()");
738
739 resp_disp(srcId, cl,"b",&ati_user_output_cfg[srcId].CRC_stat);
740 return (ATI_CMPL);
741 }
742
743 /*>
744 +--------------------------------------------------------------------+
745 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
746 | STATE : code ROUTINE : atPlusCSTA |
747 +--------------------------------------------------------------------+
748
749 PURPOSE : +CSTA command (Select type of address)
750 */
751
752 GLOBAL T_ATI_RSLT setatPlusCSTA(char *cl, UBYTE srcId)
753 {
754 SHORT toa_val=0;
755 T_ACI_TOA type;
756 #ifdef FF_ATI_BAT
757 T_ACI_TOA *p_type=NULL;
758 #endif /* FF_ATI_BAT */
759 T_ACI_RETURN ret = AT_FAIL;
760
761 cl = parse(cl, "r", &toa_val);
762 if (!cl)
763 {
764 cmdCmeError(CME_ERR_OpNotAllow);
765 return (ATI_FAIL);
766 }
767 #ifdef FF_ATI_BAT
768 p_type = &type;
769 if (toa_val EQ 0)
770 p_type = NULL;
771 else
772 #endif /* FF_ATI_BAT */
773 {
774 type=toa_demerge(toa_val);
775 if (type.ton < 0 OR type.npi < 0)
776 {
777 cmdCmeError(CME_ERR_OpNotAllow);
778 return (ATI_FAIL);
779 }
780 }
781
782 #ifdef FF_ATI_BAT
783 {
784 T_BAT_cmd_send cmd;
785 T_BAT_cmd_set_plus_csta my_bat_set_plus_csta;
786
787 TRACE_FUNCTION("setatPlusCSTA() calls bat_send() <=== as APPLICATION");
788
789 memset(&my_bat_set_plus_csta, 0, sizeof(my_bat_set_plus_csta));
790 cmd.ctrl_params = BAT_CMD_SET_PLUS_CSTA;
791 cmd.params.ptr_set_plus_csta = &my_bat_set_plus_csta;
792
793 my_bat_set_plus_csta.type = (S16)p_type;
794
795 bat_send(ati_bat_get_client(srcId), &cmd);
796
797 return ATI_EXCT; /* executing, because response is passed by callback function */
798 }
799 #else /* OLD FUNCTION BODY */
800
801 TRACE_FUNCTION("setatPLusCSTA()");
802
803 ret = sAT_PlusCSTA((T_ACI_CMD_SRC)srcId, &type);
804
805 return (map_aci_2_ati_rslt (ret));
806
807 #endif /* no FF_ATI_BAT*/
808 }
809
810 GLOBAL T_ATI_RSLT queatPlusCSTA(char *cl, UBYTE srcId)
811 {
812 T_ACI_RETURN ret = AT_FAIL;
813 T_ACI_TOA type;
814 SHORT toa_val = 0;
815
816 TRACE_FUNCTION("queatPLusCSTA()");
817
818 ret = qAT_PlusCSTA((T_ACI_CMD_SRC)srcId,&type);
819 toa_val = toa_merge (type);
820 if (ret EQ AT_CMPL)
821 {
822 resp_disp(srcId, cl,"s",&toa_val);
823 }
824 else
825 {
826 cmdCmeError(CME_ERR_Unknown);
827 }
828 return (map_aci_2_ati_rslt (ret));
829 }
830
831 /*
832 +--------------------------------------------------------------------+
833 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
834 | STATE : code ROUTINE : atPlusCHLD |
835 +--------------------------------------------------------------------+
836
837 PURPOSE : common function for +/%CHLD command
838 */
839 LOCAL T_ATI_RSLT setatPlus_PercentCHLD(char *cl, UBYTE srcId, T_ACI_CHLD_CMD cmdType)
840 {
841 T_ACI_RETURN ret = AT_FAIL;
842 T_ACI_CHLD_MOD mode = CHLD_MOD_NotPresent;
843 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
844 CHAR CHLD_type = '\0';
845 CHAR X_prm[2];
846
847 X_prm[0] = (CHAR)NOT_PRESENT_8BIT;
848
849 /* check first parameter of CHLD */
850 CHLD_type = *cl;
851 ++cl;
852
853 /* check for special PERCENT command */
854 if((CHLD_type EQ '6') AND (cmdType NEQ CHLD_PercentCmd))
855 {
856 cmdCmeError(CME_ERR_OpNotAllow);
857 return (ATI_FAIL);
858 }
859
860 /* check for rest of parameter if necessary (only for AT+CHLD=1 / 2 / or 4) */
861 if( CHLD_type EQ '1'
862 OR CHLD_type EQ '2'
863 OR CHLD_type EQ '4'
864 OR CHLD_type EQ '6'
865 OR CHLD_type EQ '7' )
866 {
867 /* possibility of an X or directory parameter */
868 if (*cl EQ 0 OR *cl EQ ';') /* end of command */
869 {
870 X_prm[0] = (CHAR)NOT_PRESENT_8BIT;
871 }
872 else
873 {
874 if( *cl < '0' OR *cl > '9')
875 {
876 cmdCmeError(CME_ERR_OpNotAllow);
877 return (ATI_FAIL);
878 }
879 else
880 {
881 X_prm[0] = *cl;
882 X_prm[1] = '\0';
883 cl++;
884 }
885 }
886 }
887
888 switch(CHLD_type)
889 {
890 case ('0'):
891 mode = CHLD_MOD_RelHldOrUdub;
892 break;
893
894 case ('1'):
895 if ( X_prm[0] EQ (CHAR)NOT_PRESENT_8BIT )
896 {
897 mode = CHLD_MOD_RelActAndAcpt;
898 }
899 else
900 {
901 mode = CHLD_MOD_RelActSpec;
902 }
903 break;
904
905 case('2'):
906 if ( X_prm[0] EQ (CHAR)NOT_PRESENT_8BIT )
907 {
908 mode = CHLD_MOD_HldActAndAcpt;
909 }
910 else
911 {
912 mode = CHLD_MOD_HldActExc;
913 }
914 break;
915
916 case('3'):
917 mode = CHLD_MOD_AddHld;
918 break;
919
920 case('4'):
921 mode = CHLD_MOD_Ect;
922 break;
923
924 case('5'):
925 mode = CHLD_MOD_Ccbs;
926 break;
927
928 case('6'):
929 /* S60/Symbian requires an extra mode in %CHLD only:
930 retrieving of an [specific] hold call
931 without affecting of an waiting call */
932 if ( X_prm[0] EQ (CHAR)NOT_PRESENT_8BIT )
933 {
934 mode = CHLD_MOD_RetrieveHoldCall;
935 }
936 else
937 {
938 mode = CHLD_MOD_RetrieveHoldCallSpec;
939 }
940 break;
941
942 case('7'):
943 /* BMI requires an extra mode in %CHLD only:
944 releasing of an [specific] hold call of any type */
945 if ( X_prm[0] EQ (CHAR)NOT_PRESENT_8BIT )
946 {
947 cmdCmeError(CME_ERR_OpNotAllow);
948 return (ATI_FAIL);
949 }
950 else
951 {
952 mode = CHLD_MOD_RelAnySpec;
953 }
954 break;
955
956 case('h'):
957 case('H'):
958 /* FTA requires an extra mode: Put on hold (without
959 accepting automatically waiting or held calls) */
960 mode = CHLD_MOD_OnlyHold;
961 break;
962
963 case('i'):
964 case('I'):
965 /* Release dialing call, without dropping current call. */
966 mode = CHLD_MOD_RelDialCall;
967 break;
968
969 default:
970 cmdCmeError(CME_ERR_OpNotAllow);
971 return (ATI_FAIL);
972 }
973
974 #ifdef FF_ATI_BAT
975 {
976 T_BAT_cmd_send cmd;
977 T_BAT_cmd_set_percent_chld my_bat_set_percent_chld;
978
979 TRACE_FUNCTION("setatPlus_PercentCHLD() calls bat_send() <=== as APPLICATION");
980
981 memset(&my_bat_set_percent_chld, 0, sizeof(my_bat_set_percent_chld));
982 cmd.ctrl_params = BAT_CMD_SET_PERCENT_CHLD;
983 cmd.params.ptr_set_percent_chld = &my_bat_set_percent_chld;
984
985 my_bat_set_percent_chld.n = mode;
986 my_bat_set_percent_chld.x = (S16)&X_prm;
987 src_params->curAtCmd = AT_CMD_CHLD;
988 bat_send(ati_bat_get_client(srcId), &cmd);
989
990 return ATI_EXCT; /* executing, because response is passed by callback function */
991 }
992 #else /* OLD FUNCTION BODY */
993
994 TRACE_FUNCTION("setatPlus_PercentCHLD()");
995
996 if( X_prm[0] NEQ (CHAR)NOT_PRESENT_8BIT )
997 {
998 if(cmdType EQ CHLD_PercentCmd)
999 {
1000 ret = sAT_PercentCHLD( (T_ACI_CMD_SRC)srcId, mode, X_prm );
1001 }
1002 else
1003 {
1004 ret = sAT_PlusCHLD( (T_ACI_CMD_SRC)srcId, mode, X_prm );
1005 }
1006 }
1007 else
1008 {
1009 if(cmdType EQ CHLD_PercentCmd)
1010 {
1011 ret = sAT_PercentCHLD( (T_ACI_CMD_SRC)srcId, mode, NULL );
1012 }
1013 else
1014 {
1015 ret = sAT_PlusCHLD( (T_ACI_CMD_SRC)srcId, mode, NULL );
1016 }
1017 }
1018
1019 switch( ret )
1020 {
1021 case AT_CMPL:
1022 break;
1023
1024 case AT_EXCT:
1025 src_params->curAtCmd = AT_CMD_CHLD;
1026 break;
1027
1028 case AT_BUSY:
1029 cmdCmeError(CME_ERR_OpNotAllow);
1030 break;
1031
1032 default:
1033 cmdCmeError(CME_ERR_Unknown);
1034 break;
1035 }
1036 return (map_aci_2_ati_rslt (ret));
1037
1038 #endif /* no FF_ATI_BAT*/
1039 }
1040
1041 /*
1042 +--------------------------------------------------------------------+
1043 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1044 | STATE : code ROUTINE : atPlusCHLD |
1045 +--------------------------------------------------------------------+
1046
1047 PURPOSE : +CHLD command
1048 */
1049
1050 GLOBAL T_ATI_RSLT setatPlusCHLD(char *cl, UBYTE srcId)
1051 {
1052 TRACE_FUNCTION("setatPlusCHLD()");
1053
1054 return( setatPlus_PercentCHLD(cl, srcId, CHLD_PlusCmd) );
1055 }
1056
1057 /*
1058 +--------------------------------------------------------------------+
1059 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1060 | STATE : code ROUTINE : atPercentCHLD |
1061 +--------------------------------------------------------------------+
1062
1063 PURPOSE : %CHLD command (same as +CHLD but custom specific)
1064 */
1065
1066 GLOBAL T_ATI_RSLT setatPercentCHLD(char *cl, UBYTE srcId)
1067 {
1068 TRACE_FUNCTION("setatPercentCHLD()");
1069
1070 return( setatPlus_PercentCHLD(cl, srcId, CHLD_PercentCmd) );
1071 }
1072
1073
1074 /*
1075 +--------------------------------------------------------------------+
1076 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1077 | STATE : code ROUTINE : atPlusCHUP |
1078 +--------------------------------------------------------------------+
1079
1080 PURPOSE : +CHUP command (Hangs up call)
1081 */
1082 GLOBAL T_ATI_RSLT setatPlusCHUP (char *cl, UBYTE srcId)
1083 {
1084 T_ACI_RETURN ret = AT_FAIL;
1085 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1086
1087 TRACE_FUNCTION("setatPlusCHUP()");
1088
1089 if (*cl EQ ';' OR *cl EQ 0)
1090 {
1091 #ifdef FF_ATI_BAT
1092 {
1093 T_BAT_cmd_send cmd;
1094 T_BAT_no_parameter dummy;
1095 cmd.ctrl_params = BAT_CMD_SET_PLUS_CHUP;
1096 dummy.bat_dummy = 0xFF;
1097 cmd.params.ptr_set_plus_chup = &dummy;
1098
1099 TRACE_FUNCTION("setatPlusCHUP() calls bat_send() <=== as APPLICATION");
1100
1101 if( at.rngPrms.isRng EQ TRUE )
1102 {
1103 ati_stop_ring();
1104 }
1105 src_params->curAtCmd = AT_CMD_CHUP;
1106
1107 bat_send(ati_bat_get_client(srcId), &cmd);
1108
1109 return (ATI_EXCT); /* executing, because response is passed by callback function */
1110 }
1111 #else /* OLD FUNCTION BODY */
1112 ret=sAT_PlusCHUP((T_ACI_CMD_SRC)srcId);
1113 if (ret EQ AT_CMPL)
1114 {
1115 return (ATI_CMPL);
1116 }
1117
1118 else if (ret EQ AT_EXCT)
1119 {
1120 if( at.rngPrms.isRng EQ TRUE )
1121 {
1122 ati_stop_ring();
1123 }
1124 src_params->curAtCmd = AT_CMD_CHUP;
1125 }
1126 else
1127 {
1128 cmdCmeError(CME_ERR_Unknown);
1129 }
1130 #endif
1131 }
1132 else
1133 {
1134 cmdCmeError(CME_ERR_OpNotAllow);
1135 }
1136 return (map_aci_2_ati_rslt (ret));
1137 }
1138
1139
1140 /*
1141 +--------------------------------------------------------------------+
1142 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1143 | STATE : code ROUTINE : atPlusCLIP |
1144 +--------------------------------------------------------------------+
1145
1146 PURPOSE : +CLIP command (calling line identification presentation)
1147 */
1148 GLOBAL T_ATI_RSLT setatPlusCLIP (char *cl, UBYTE srcId)
1149 {
1150 TRACE_FUNCTION("setatPlusCLIP()");
1151
1152 return(GenAtCR_C( cl, srcId, AT_CMD_CLIP ));
1153 }
1154
1155 GLOBAL T_ATI_RSLT queatPlusCLIP (char *cl, UBYTE srcId)
1156 {
1157 T_ACI_RETURN ret = AT_FAIL;
1158 T_ACI_CLIP_STAT stat = CLIP_STAT_NotPresent;
1159 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1160
1161 TRACE_FUNCTION("queatPlusCLIP()");
1162
1163 #ifdef FF_ATI_BAT
1164 {
1165 T_BAT_cmd_send cmd;
1166 T_BAT_no_parameter dummy;
1167
1168 cmd.ctrl_params=BAT_CMD_QUE_PLUS_CLIP;
1169 dummy.bat_dummy = 0xFF;
1170 cmd.params.ptr_que_plus_clip = &dummy;
1171 src_params->curAtCmd = AT_CMD_CLIP;
1172 bat_send(ati_bat_get_client(srcId), &cmd);
1173 return(ATI_EXCT);
1174 }
1175 #else /* no FF_ATI_BAT */
1176
1177 ret = qAT_PlusCLIP((T_ACI_CMD_SRC)srcId,&stat);
1178
1179 if (ret EQ AT_CMPL)
1180 {
1181 resp_disp(srcId, cl,"be",&ati_user_output_cfg[srcId].CLIP_stat,&stat);
1182 }
1183 else if (ret EQ AT_EXCT)
1184 {
1185 src_params->curAtCmd = AT_CMD_CLIP;
1186 }
1187 else if (ret EQ AT_FAIL)
1188 {
1189 cmdCmeError(CME_ERR_Unknown);
1190 }
1191 return (map_aci_2_ati_rslt (ret));
1192
1193 #endif /* no FF_ATI_BAT */
1194 }
1195
1196 /*
1197 +--------------------------------------------------------------------+
1198 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1199 | STATE : code ROUTINE : atPlusCDIP |
1200 +--------------------------------------------------------------------+
1201
1202 PURPOSE : +CDIP command (calling line identification presentation)
1203 */
1204 GLOBAL T_ATI_RSLT setatPlusCDIP (char *cl, UBYTE srcId)
1205 {
1206 TRACE_FUNCTION("setatPlusCDIP()");
1207
1208 return(GenAtCR_C( cl, srcId, AT_CMD_CDIP ));
1209 }
1210
1211 /*
1212 +--------------------------------------------------------------------+
1213 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1214 | STATE : code ROUTINE : queatPlusCDIP |
1215 +--------------------------------------------------------------------+
1216
1217 PURPOSE : +CDIP command (calling line identification presentation)
1218 */
1219 GLOBAL T_ATI_RSLT queatPlusCDIP (char *cl, UBYTE srcId)
1220 {
1221 T_ACI_RETURN ret = AT_CMPL;
1222 T_ACI_CDIP_STAT stat = CDIP_STAT_Unknown; /* Return this for XT6 - No Network Interrogation */
1223 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1224
1225 #ifdef FF_ATI_BAT
1226 {
1227 T_BAT_cmd_send cmd;
1228 T_BAT_no_parameter dummy;
1229
1230 cmd.ctrl_params=BAT_CMD_QUE_PLUS_CDIP;
1231 dummy.bat_dummy = 0xFF;
1232 cmd.params.ptr_que_plus_cdip = &dummy;
1233 src_params->curAtCmd = AT_CMD_CDIP;
1234 bat_send(ati_bat_get_client(srcId), &cmd);
1235 return(ATI_EXCT);
1236 }
1237 #else /* no FF_ATI_BAT */
1238 TRACE_FUNCTION("queatPlusCDIP()");
1239
1240 resp_disp(srcId, cl,"be",&ati_user_output_cfg[srcId].CDIP_stat,&stat);
1241
1242 return (map_aci_2_ati_rslt (ret));
1243 #endif /* FF_ATI_BAT */
1244 }
1245
1246 /*
1247 +--------------------------------------------------------------------+
1248 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1249 | STATE : code ROUTINE : atPlusCOLP |
1250 +--------------------------------------------------------------------+
1251
1252 PURPOSE : +COLP command (connected line identification presentation)
1253 */
1254
1255 GLOBAL T_ATI_RSLT setatPlusCOLP (char *cl, UBYTE srcId)
1256 {
1257 TRACE_FUNCTION("setatPlusCOLP()");
1258
1259 return(GenAtCR_C( cl, srcId, AT_CMD_COLP ));
1260 }
1261
1262 GLOBAL T_ATI_RSLT queatPlusCOLP (char *cl, UBYTE srcId)
1263 {
1264 T_ACI_COLP_STAT stat = COLP_STAT_NotPresent;
1265 T_ACI_RETURN ret = AT_FAIL;
1266 UBYTE x = 0;
1267 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1268
1269 TRACE_FUNCTION("queatPlusCOLP()");
1270
1271 ret = qAT_PlusCOLP((T_ACI_CMD_SRC)srcId,&stat);
1272 if (ret EQ AT_CMPL)
1273 {
1274 x = (at.flags.COLP_stat?1:0);
1275 resp_disp(srcId, cl,"be",&x,&stat);
1276 }
1277 else if (ret EQ AT_EXCT)
1278 {
1279 src_params->curAtCmd = AT_CMD_COLP;
1280 }
1281 else if (ret EQ AT_FAIL)
1282 {
1283 cmdCmeError(CME_ERR_Unknown);
1284 }
1285 return (map_aci_2_ati_rslt (ret));
1286 }
1287
1288
1289 /*
1290 +--------------------------------------------------------------------+
1291 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1292 | STATE : code ROUTINE : atPlusCLIR |
1293 +--------------------------------------------------------------------+
1294
1295 PURPOSE : +CLIR command (connected line identification restriction)
1296 */
1297
1298 GLOBAL T_ATI_RSLT setatPlusCLIR (char *cl, UBYTE srcId)
1299 {
1300 T_ACI_RETURN ret = AT_FAIL;
1301 T_ACI_CLIR_MOD mode = CLIR_MOD_NotPresent;
1302
1303
1304 switch(*cl)
1305 {
1306 case('0'):
1307 {
1308 mode=CLIR_MOD_Subscript;
1309 cl++;
1310 break;
1311 }
1312 case('1'):
1313 {
1314 mode=CLIR_MOD_Invoc;
1315 cl++;
1316 break;
1317 }
1318 case('2'):
1319 {
1320 mode=CLIR_MOD_Supp;
1321 cl++;
1322 break;
1323 }
1324 case('\0'):
1325 {
1326 break;
1327 }
1328 default:
1329 {
1330 cmdCmeError(CME_ERR_OpNotAllow);
1331 return (ATI_FAIL);
1332 }
1333 }
1334
1335 if (!(*cl EQ 0 OR *cl EQ ';'))
1336 {
1337 cmdCmeError(CME_ERR_OpNotAllow);
1338 return (ATI_FAIL);
1339 }
1340
1341 #ifdef FF_ATI_BAT
1342 {
1343 T_BAT_cmd_send cmd;
1344 T_BAT_cmd_set_plus_clir my_bat_set_plus_clir;
1345
1346 TRACE_FUNCTION("setatPLusCLIR() calls bat_send() <=== as APPLICATION");
1347
1348 memset(&my_bat_set_plus_clir, 0, sizeof(my_bat_set_plus_clir));
1349 cmd.ctrl_params = BAT_CMD_SET_PLUS_CLIR;
1350 cmd.params.ptr_set_plus_clir = &my_bat_set_plus_clir;
1351
1352 my_bat_set_plus_clir.n = mode;
1353
1354 bat_send(ati_bat_get_client(srcId), &cmd);
1355
1356 return ATI_EXCT; /* executing, because response is passed by callback function */
1357 }
1358 #else /* OLD FUNCTION BODY */
1359
1360 TRACE_FUNCTION("setatPLusCLIR()");
1361
1362 ret = sAT_PlusCLIR((T_ACI_CMD_SRC)srcId,mode);
1363 return (map_aci_2_ati_rslt (ret));
1364
1365 #endif /* no FF_ATI_BAT*/
1366 }
1367
1368 GLOBAL T_ATI_RSLT queatPlusCLIR (char *cl, UBYTE srcId)
1369 {
1370 T_ACI_RETURN ret = AT_FAIL;
1371 T_ACI_CLIR_STAT stat = CLIR_STAT_NotPresent;
1372 T_ACI_CLIR_MOD mode = CLIR_MOD_NotPresent;
1373 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1374
1375 TRACE_FUNCTION("queatPLusCLIR()");
1376
1377 #ifdef FF_ATI_BAT
1378 {
1379 T_BAT_cmd_send cmd;
1380 T_BAT_no_parameter dummy;
1381
1382 cmd.ctrl_params=BAT_CMD_QUE_PLUS_CLIR;
1383 dummy.bat_dummy = 0xFF;
1384 cmd.params.ptr_que_plus_clir = &dummy;
1385 src_params->curAtCmd = AT_CMD_CLIR;
1386 bat_send(ati_bat_get_client(srcId), &cmd);
1387 return(ATI_EXCT);
1388 }
1389 #else /* OLD FUNCTION BODY */
1390
1391 ret = qAT_PlusCLIR ((T_ACI_CMD_SRC)srcId,&mode,&stat);
1392 switch (ret)
1393 {
1394 /* case AT_CMPL:
1395 {
1396 sprintf(sa,"%s%d,%d",me,mode,stat);
1397 io_sendMessage(sa, ATI_NORMAL_OUTPUT);
1398 break;
1399 } */ /* never happens as far as I know */
1400 case AT_EXCT:
1401 {
1402 src_params->curAtCmd = AT_CMD_CLIR;
1403 break;
1404 }
1405 case AT_FAIL:
1406 {
1407 cmdCmeError (CME_ERR_Unknown);
1408 break;
1409 }
1410 }
1411 return (map_aci_2_ati_rslt (ret));
1412 #endif /* FF_ATI_BAT */
1413 }
1414
1415
1416 /*
1417 +--------------------------------------------------------------------+
1418 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1419 | STATE : code ROUTINE : atPlusCCUG |
1420 +--------------------------------------------------------------------+
1421
1422 PURPOSE : +CCUG command (closed useg group settings)
1423 */
1424 GLOBAL T_ATI_RSLT setatPlusCCUG (char * cl, UBYTE srcId)
1425 {
1426 T_ACI_RETURN ret = AT_FAIL;
1427 T_ACI_CCUG_MOD mode = CCUG_MOD_NotPresent;
1428 T_ACI_CCUG_IDX idx = CCUG_IDX_NotPresent;
1429 T_ACI_CCUG_INFO info = CCUG_INFO_NotPresent;
1430
1431 cl = parse(cl, "ddd", &mode, &idx, &info);
1432 if (!cl)
1433 {
1434 cmdCmeError (CME_ERR_OpNotAllow);
1435 return (ATI_FAIL);
1436 }
1437
1438 #ifdef FF_ATI_BAT
1439 {
1440 T_BAT_cmd_send cmd;
1441 T_BAT_cmd_set_plus_ccug my_bat_set_plus_ccug;
1442
1443 TRACE_FUNCTION("setatPlusCCUG() calls bat_send() <=== as APPLICATION");
1444
1445 memset(&my_bat_set_plus_ccug, 0, sizeof(my_bat_set_plus_ccug));
1446 cmd.ctrl_params = BAT_CMD_SET_PLUS_CCUG;
1447 cmd.params.ptr_set_plus_ccug = &my_bat_set_plus_ccug;
1448
1449 my_bat_set_plus_ccug.n = mode;
1450 my_bat_set_plus_ccug.index = idx;
1451 my_bat_set_plus_ccug.info = info;
1452
1453 bat_send(ati_bat_get_client(srcId), &cmd);
1454
1455 return ATI_EXCT; /* executing, because response is passed by callback function */
1456 }
1457 #else /* OLD FUNCTION BODY */
1458
1459 TRACE_FUNCTION("setatPlusCCUG()");
1460
1461 ret = sAT_PlusCCUG((T_ACI_CMD_SRC)srcId,mode,idx,info);
1462 if (ret EQ AT_FAIL)
1463 {
1464 cmdCmeError (CME_ERR_Unknown);
1465 }
1466 return (map_aci_2_ati_rslt (ret));
1467
1468 #endif /* no FF_ATI_BAT*/
1469 }
1470
1471 GLOBAL T_ATI_RSLT queatPlusCCUG (char * cl, UBYTE srcId)
1472 {
1473 T_ACI_RETURN ret = AT_FAIL;
1474 T_ACI_CCUG_MOD mode = CCUG_MOD_NotPresent;
1475 T_ACI_CCUG_IDX idx = CCUG_IDX_NotPresent;
1476 T_ACI_CCUG_INFO info = CCUG_INFO_NotPresent;
1477
1478 TRACE_FUNCTION("queatPlusCCUG()");
1479
1480 ret = qAT_PlusCCUG ((T_ACI_CMD_SRC)srcId,&mode,&idx,&info);
1481 switch (ret)
1482 {
1483 case AT_CMPL:
1484 {
1485 resp_disp (srcId, cl,"eee",&mode,&idx,&info);
1486 break;
1487 }
1488 case AT_FAIL:
1489 {
1490 cmdCmeError (CME_ERR_Unknown);
1491 break;
1492 }
1493 }
1494 return (map_aci_2_ati_rslt (ret));
1495 }
1496
1497 /*
1498 +--------------------------------------------------------------------+
1499 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1500 | STATE : code ROUTINE : atPlusCMOD |
1501 +--------------------------------------------------------------------+
1502
1503 PURPOSE : +CMOD command (call mode)
1504 */
1505
1506 GLOBAL T_ATI_RSLT setatPlusCMOD (char *cl, UBYTE srcId)
1507 {
1508 T_ACI_RETURN ret = AT_FAIL;
1509 T_ACI_CMOD_MOD mode = CMOD_MOD_NotPresent;
1510
1511 cl = parse(cl, "d", &mode);
1512 if (!cl)
1513 {
1514 cmdCmeError (CME_ERR_OpNotAllow);
1515 return (ATI_FAIL);
1516 }
1517
1518 #ifdef FF_ATI_BAT
1519 {
1520 T_BAT_cmd_send cmd;
1521 T_BAT_cmd_set_plus_cmod my_bat_set_plus_cmod;
1522
1523 TRACE_FUNCTION("setatPLusCMOD() calls bat_send() <=== as APPLICATION");
1524
1525 memset(&my_bat_set_plus_cmod, 0, sizeof(my_bat_set_plus_cmod));
1526 cmd.ctrl_params = BAT_CMD_SET_PLUS_CMOD;
1527 cmd.params.ptr_set_plus_cmod = &my_bat_set_plus_cmod;
1528
1529 my_bat_set_plus_cmod.mode = mode;
1530
1531 bat_send(ati_bat_get_client(srcId), &cmd);
1532
1533 return ATI_EXCT; /* executing, because response is passed by callback function */
1534 }
1535 #else /* OLD FUNCTION BODY */
1536
1537 TRACE_FUNCTION("setatPLusCMOD()");
1538
1539 ret = sAT_PlusCMOD ((T_ACI_CMD_SRC)srcId,mode);
1540 switch (ret)
1541 {
1542 case AT_FAIL:
1543 cmdCmeError (CME_ERR_Unknown);
1544 break;
1545
1546 default:
1547 break;
1548 }
1549 return (map_aci_2_ati_rslt (ret));
1550
1551 #endif /* no FF_ATI_BAT*/
1552 }
1553
1554
1555 GLOBAL T_ATI_RSLT queatPlusCMOD (char *cl, UBYTE srcId)
1556 {
1557 T_ACI_RETURN ret = AT_FAIL;
1558 T_ACI_CMOD_MOD mode = CMOD_MOD_NotPresent;
1559
1560 TRACE_FUNCTION("queatPLusCMOD()");
1561
1562 ret = qAT_PlusCMOD ((T_ACI_CMD_SRC)srcId,&mode);
1563
1564 switch (ret)
1565 {
1566 case AT_CMPL:
1567 {
1568 resp_disp (srcId, cl, "e",&mode);
1569 break;
1570 }
1571 case AT_FAIL:
1572 {
1573 cmdCmeError (CME_ERR_OpNotAllow);
1574 break;
1575 }
1576 }
1577 return (map_aci_2_ati_rslt (ret));
1578 }
1579
1580 /*
1581 +--------------------------------------------------------------------+
1582 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1583 | STATE : code ROUTINE : atPlusCR |
1584 +--------------------------------------------------------------------+
1585
1586 PURPOSE : +CR command (Service reporting control)
1587 */
1588
1589 GLOBAL T_ATI_RSLT setatPlusCR (char *cl, UBYTE srcId)
1590 {
1591 TRACE_FUNCTION("setatPlusCR()");
1592
1593 return (GenAtCR_C( cl, srcId, AT_CMD_CR ));
1594 }
1595
1596 GLOBAL T_ATI_RSLT queatPlusCR (char *cl, UBYTE srcId)
1597 {
1598 UBYTE x = 0;
1599
1600 TRACE_FUNCTION("queatPlusCR()");
1601
1602 x = (ati_user_output_cfg[srcId].CR_stat?1:0);
1603
1604 resp_disp (srcId, cl, "b", &x);
1605
1606 return (ATI_CMPL);
1607 }
1608
1609 /*
1610 +--------------------------------------------------------------------+
1611 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1612 | STATE : code ROUTINE : atPlusCAOC |
1613 +--------------------------------------------------------------------+
1614
1615 PURPOSE : +CAOC command (Advice of Charge)
1616 */
1617 GLOBAL T_ATI_RSLT setatPlusCAOC (char* cl, UBYTE srcId)
1618 {
1619 LONG ccm = 0L;
1620 SHORT mode = 0;
1621 T_ACI_RETURN ret = AT_FAIL;
1622
1623 switch ( *cl )
1624 {
1625 case('\0'):
1626 break;
1627
1628 default:
1629 {
1630 cl = parse(cl, "d", &mode);
1631 if (!cl)
1632 {
1633 cmdCmeError (CME_ERR_OpNotAllow);
1634 return (ATI_FAIL);
1635 }
1636
1637 switch(mode)
1638 {
1639 case (0):
1640 /*
1641 * AT+CAOC=0 queries the actual ccm value
1642 */
1643 cl++;
1644 break;
1645
1646 case (1):
1647 /*
1648 * AT+CAOC=1 deactivates the unsolicited report mode
1649 */
1650 ati_user_output_cfg[srcId].CAOC_stat=0;
1651 return (ATI_CMPL);
1652
1653 case (2):
1654 /*
1655 * AT+CAOC=2 activates the unsolicited report mode
1656 */
1657 ati_user_output_cfg[srcId].CAOC_stat=1;
1658 return (ATI_CMPL);
1659
1660 default:
1661 cmdCmeError (CME_ERR_OpNotAllow);
1662 return (ATI_FAIL);
1663 }
1664 break;
1665 }
1666 }
1667
1668 #ifdef FF_ATI_BAT
1669 {
1670 T_BAT_cmd_send cmd;
1671 T_BAT_cmd_set_plus_caoc my_bat_set_plus_caoc;
1672
1673 TRACE_FUNCTION("setatPLusCAOC() calls bat_send() <=== as APPLICATION");
1674
1675 memset(&my_bat_set_plus_caoc, 0, sizeof(my_bat_set_plus_caoc));
1676 cmd.ctrl_params = BAT_CMD_SET_PLUS_CAOC;
1677 cmd.params.ptr_set_plus_caoc = &my_bat_set_plus_caoc;
1678
1679 my_bat_set_plus_caoc.mode = mode;
1680
1681 bat_send(ati_bat_get_client(srcId), &cmd);
1682
1683 return ATI_EXCT; /* executing, because response is passed by callback function */
1684 }
1685 #else /* OLD FUNCTION BODY */
1686
1687 TRACE_FUNCTION("setatPLusCAOC()");
1688
1689 ret = qAT_PlusCAOC((T_ACI_CMD_SRC)srcId,&ccm);
1690 sprintf (g_sa,"+CAOC: \"%06X\"", ccm);
1691 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT);
1692 return (map_aci_2_ati_rslt (ret));
1693
1694 #endif /* no FF_ATI_BAT*/
1695 }
1696
1697
1698 GLOBAL T_ATI_RSLT queatPlusCAOC (char* cl, UBYTE srcId)
1699 {
1700 UBYTE x = 0;
1701
1702 TRACE_FUNCTION("queatPLusCAOC()");
1703
1704 /*
1705 * AT+CAOC? requests the actual mode
1706 */
1707 x = ati_user_output_cfg[srcId].CAOC_stat + 1;
1708
1709 resp_disp(srcId, cl,"b",&x);
1710
1711 return (ATI_CMPL);
1712 }
1713
1714 /*
1715 +--------------------------------------------------------------------+
1716 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1717 | STATE : code ROUTINE : setatPlusCACM |
1718 +--------------------------------------------------------------------+
1719
1720 PURPOSE : +CACM command (Advice of Charge, Accumulated Call Meter)
1721 */
1722 GLOBAL T_ATI_RSLT setatPlusCACM (char* cl, UBYTE srcId)
1723 {
1724 char pin2 [MAX_PWD_LENGTH] = {0} ;
1725 T_ACI_RETURN ret = AT_FAIL;
1726 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1727
1728 cl = parse(cl, "n", (LONG)MAX_PWD_LENGTH, &pin2);
1729 if ( !cl )
1730 {
1731 cmdCmeError(CME_ERR_OpNotAllow);
1732 return (ATI_FAIL);
1733 }
1734
1735 #ifdef FF_ATI_BAT
1736 {
1737 T_BAT_cmd_send cmd;
1738 T_BAT_cmd_set_plus_cacm my_bat_set_plus_cacm;
1739
1740 TRACE_FUNCTION("setatPLusCACM() calls bat_send() <=== as APPLICATION");
1741
1742 memset(&my_bat_set_plus_cacm, 0, sizeof(my_bat_set_plus_cacm));
1743 cmd.ctrl_params = BAT_CMD_SET_PLUS_CACM;
1744 cmd.params.ptr_set_plus_cacm = &my_bat_set_plus_cacm;
1745
1746 my_bat_set_plus_cacm.c_passwd = strlen(pin2);
1747 memcpy(my_bat_set_plus_cacm.passwd, pin2, my_bat_set_plus_cacm.c_passwd);
1748 src_params->curAtCmd = AT_CMD_CACM;
1749 bat_send(ati_bat_get_client(srcId), &cmd);
1750
1751 return ATI_EXCT; /* executing, because response is passed by callback function */
1752 }
1753 #else /* OLD FUNCTION BODY */
1754
1755 TRACE_FUNCTION("setatPLusCACM()");
1756
1757 ret = sAT_PlusCACM((T_ACI_CMD_SRC)srcId,pin2);
1758
1759 switch (ret)
1760 {
1761 case AT_EXCT:
1762 {
1763 src_params->curAtCmd = AT_CMD_CACM;
1764 break;
1765 }
1766 case AT_BUSY:
1767 {
1768 cmdCmeError (CME_ERR_SimBusy);
1769 break;
1770 }
1771 case AT_FAIL:
1772 {
1773 cmdCmeError (CME_ERR_OpNotAllow);
1774 break;
1775 }
1776 }
1777 return (map_aci_2_ati_rslt (ret));
1778
1779 #endif /* no FF_ATI_BAT*/
1780 }
1781
1782
1783 GLOBAL T_ATI_RSLT queatPlusCACM (char* cl, UBYTE srcId)
1784 {
1785 LONG acm = 0L;
1786 T_ACI_RETURN ret = AT_FAIL;
1787
1788 TRACE_FUNCTION("queatPLusCACM()");
1789
1790 /*
1791 * +AT+CACM? requests the actual value
1792 */
1793 ret = qAT_PlusCACM((T_ACI_CMD_SRC)srcId,&acm);
1794 if( ret NEQ AT_CMPL )
1795 {
1796 cmdCmeError(CME_ERR_Unknown);
1797 }
1798 else
1799 {
1800 sprintf(g_sa,"+CACM: \"%06X\"", acm);
1801 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
1802 }
1803 return (map_aci_2_ati_rslt (ret));
1804 }
1805
1806
1807
1808 /*
1809 +--------------------------------------------------------------------+
1810 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1811 | STATE : code ROUTINE : atPlusCAMM |
1812 +--------------------------------------------------------------------+
1813
1814 PURPOSE : +CAMM command (Advice of Charge,
1815 Accumulated Call Meter Maximum)
1816 */
1817 GLOBAL T_ATI_RSLT setatPlusCAMM (char* cl, UBYTE srcId)
1818 {
1819 char pin2 [MAX_PWD_LENGTH] = {0};
1820 char new_acmmax [MAX_CM_LENGTH] = {0};
1821 char *pNewAcmMax = new_acmmax;
1822 LONG acmmax = 0L;
1823 T_ACI_RETURN ret = AT_FAIL;
1824 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1825
1826 cl = parse(cl,"sn",(LONG)MAX_CM_LENGTH, &new_acmmax,
1827 (LONG)MAX_PWD_LENGTH, &pin2);
1828
1829 if ( !cl OR *new_acmmax EQ '\0' )
1830 {
1831 cmdCmeError(CME_ERR_OpNotAllow);
1832 return (ATI_FAIL);
1833 }
1834
1835 pNewAcmMax = parse(pNewAcmMax, "y", &acmmax);
1836 if ( !pNewAcmMax )
1837 {
1838 cmdCmeError(CME_ERR_OpNotAllow);
1839 return (ATI_FAIL);
1840 }
1841
1842 #ifdef FF_ATI_BAT
1843 {
1844 T_BAT_cmd_send cmd;
1845 T_BAT_cmd_set_plus_camm my_bat_set_plus_camm;
1846
1847 TRACE_FUNCTION("setatPLusCAMM() calls bat_send() <=== as APPLICATION");
1848
1849 memset(&my_bat_set_plus_camm, 0, sizeof(my_bat_set_plus_camm));
1850 cmd.ctrl_params = BAT_CMD_SET_PLUS_CAMM;
1851 cmd.params.ptr_set_plus_camm = &my_bat_set_plus_camm;
1852
1853 my_bat_set_plus_camm.acmmax = (S32)acmmax;
1854 my_bat_set_plus_camm.c_passwd = strlen(pin2);
1855 memcpy(my_bat_set_plus_camm.passwd, pin2, my_bat_set_plus_camm.c_passwd);
1856 src_params->curAtCmd = AT_CMD_CAMM;
1857 bat_send(ati_bat_get_client(srcId), &cmd);
1858
1859 return ATI_EXCT; /* executing, because response is passed by callback function */
1860 }
1861 #else /* OLD FUNCTION BODY */
1862
1863 TRACE_FUNCTION("setatPLusCAMM()");
1864
1865 ret = sAT_PlusCAMM((T_ACI_CMD_SRC)srcId, acmmax, pin2);
1866
1867 switch (ret)
1868 {
1869 case AT_EXCT:
1870 {
1871 src_params->curAtCmd = AT_CMD_CAMM;
1872 break;
1873 }
1874 case AT_BUSY:
1875 {
1876 cmdCmeError (CME_ERR_SimBusy);
1877 break;
1878 }
1879 default:
1880 {
1881 cmdCmeError (CME_ERR_OpNotAllow);
1882 break;
1883 }
1884 }
1885 return (map_aci_2_ati_rslt (ret));
1886
1887 #endif /* no FF_ATI_BAT*/
1888 }
1889
1890
1891 GLOBAL T_ATI_RSLT queatPlusCAMM (char* cl, UBYTE srcId)
1892 {
1893 LONG acmmax = 0L;
1894 T_ACI_RETURN ret = AT_FAIL;
1895
1896 TRACE_FUNCTION("queatPLusCAMM()");
1897
1898 /*
1899 * +AT+CAMM? requests the actual value
1900 */
1901 ret = qAT_PlusCAMM((T_ACI_CMD_SRC)srcId,&acmmax);
1902 if( ret NEQ AT_CMPL )
1903 {
1904 cmdCmeError(CME_ERR_Unknown);
1905 return (ATI_FAIL);
1906 }
1907
1908 sprintf (g_sa,"+CAMM: \"%06X\"", acmmax);
1909 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT);
1910 return (map_aci_2_ati_rslt (ret));
1911 }
1912
1913 /*
1914 +--------------------------------------------------------------------+
1915 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1916 | STATE : code ROUTINE : atPlusCPUC |
1917 +--------------------------------------------------------------------+
1918
1919 PURPOSE : +CPUC command (Advice of Charge,
1920 Price per unit and currency)
1921 */
1922 GLOBAL T_ATI_RSLT setatPlusCPUC (char* cl, UBYTE srcId)
1923 {
1924 char currency [MAX_CUR_LEN] = {0x00};
1925 char cvtdCurrency [2*MAX_CUR_LEN] = {0x00};
1926 USHORT lenCurrency = 0;
1927 USHORT lenCvtdCurrency = 0;
1928 char ppu [MAX_PPU_LENGTH] = {0x00};
1929 char pin2 [MAX_PWD_LENGTH] = {0x00};
1930 T_ACI_RETURN ret = AT_FAIL;
1931 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1932
1933 /*
1934 * AT+CPUC=currency, ppu, pw sets the PUCT with or without password.
1935 */
1936 cl = parse(cl,"zsn",
1937 (LONG)MAX_CUR_LEN,
1938 strlen(cl),
1939 cl,
1940 &lenCurrency,
1941 currency,
1942 (LONG)MAX_PPU_LENGTH,
1943 ppu,
1944 (LONG)MAX_PWD_LENGTH,
1945 pin2);
1946
1947 if ( !cl OR *ppu EQ '\0' )
1948 {
1949 cmdCmeError(CME_ERR_OpNotAllow);
1950 return (ATI_FAIL);
1951 }
1952
1953 srcId_cb = srcId;
1954 utl_chsetToGsm ((UBYTE*)currency,
1955 lenCurrency,
1956 (UBYTE*)cvtdCurrency,
1957 &lenCvtdCurrency,
1958 #ifdef REL99
1959 sizeof(cvtdCurrency),
1960 #endif
1961 GSM_ALPHA_Int);
1962
1963 #ifdef FF_ATI_BAT
1964 {
1965 T_BAT_cmd_send cmd;
1966 T_BAT_cmd_set_plus_cpuc my_bat_set_plus_cpuc;
1967
1968 TRACE_FUNCTION("setatPLusCPUC() calls bat_send() <=== as APPLICATION");
1969
1970 memset(&my_bat_set_plus_cpuc, 0, sizeof(my_bat_set_plus_cpuc));
1971 cmd.ctrl_params = BAT_CMD_SET_PLUS_CPUC;
1972 cmd.params.ptr_set_plus_cpuc = &my_bat_set_plus_cpuc;
1973
1974 my_bat_set_plus_cpuc.c_currency = (U8)lenCurrency;
1975 memcpy(my_bat_set_plus_cpuc.currency, currency, lenCurrency);
1976 my_bat_set_plus_cpuc.c_ppu = strlen(ppu);
1977 memcpy(my_bat_set_plus_cpuc.ppu, ppu, my_bat_set_plus_cpuc.c_ppu);
1978 my_bat_set_plus_cpuc.c_passwd = strlen(pin2);
1979 my_bat_set_plus_cpuc.v_passwd = my_bat_set_plus_cpuc.c_passwd ? TRUE : FALSE;
1980 memcpy(my_bat_set_plus_cpuc.passwd, pin2, my_bat_set_plus_cpuc.c_passwd);
1981 src_params->curAtCmd = AT_CMD_CPUC;
1982 bat_send(ati_bat_get_client(srcId), &cmd);
1983
1984 return ATI_EXCT; /* executing, because response is passed by callback function */
1985 }
1986 #else /* OLD FUNCTION BODY */
1987
1988 TRACE_FUNCTION("setatPLusCPUC()");
1989
1990 ret = sAT_PlusCPUC((T_ACI_CMD_SRC)srcId,cvtdCurrency,ppu,pin2);
1991
1992 switch (ret)
1993 {
1994 case AT_EXCT:
1995 {
1996 src_params->curAtCmd = AT_CMD_CPUC;
1997 break;
1998 }
1999 case AT_BUSY:
2000 {
2001 cmdCmeError (CME_ERR_SimBusy);
2002 break;
2003 }
2004 default:
2005 {
2006 cmdCmeError (CME_ERR_OpNotAllow);
2007 break;
2008 }
2009 }
2010 return (map_aci_2_ati_rslt (ret));
2011
2012 #endif /* no FF_ATI_BAT*/
2013 }
2014
2015
2016 GLOBAL T_ATI_RSLT queatPlusCPUC (char* cl, UBYTE srcId)
2017 {
2018 char currency [MAX_CUR_LEN] = {0x00};
2019 char cvtdCurrency [2*MAX_CUR_LEN] = {0x00};
2020 USHORT lenCvtdCurrency = 0;
2021 USHORT pos = 0;
2022 char ppu [MAX_PPU_LENGTH] = {0x00};
2023 T_ACI_RETURN ret = AT_FAIL;
2024
2025
2026 TRACE_FUNCTION("queatPLusCPUC()");
2027
2028 /*
2029 * +AT+CPUC? requests the actual value
2030 */
2031 ret = qAT_PlusCPUC((T_ACI_CMD_SRC)srcId,currency, ppu);
2032
2033 if( ret NEQ AT_CMPL )
2034 {
2035 cmdCmeError(CME_ERR_Unknown);
2036 return (ATI_FAIL);
2037 }
2038
2039
2040 pos = sprintf(g_sa,"+CPUC: ");
2041
2042 srcId_cb = srcId;
2043 utl_chsetFromGsm((UBYTE*)currency,
2044 (USHORT)strlen(currency),
2045 (UBYTE*)cvtdCurrency,
2046 sizeof(cvtdCurrency),
2047 &lenCvtdCurrency,
2048 GSM_ALPHA_Def);
2049 pos += sprints(g_sa+pos,cvtdCurrency,lenCvtdCurrency);
2050 pos += sprintf(g_sa+pos,",\"%s\"",ppu);
2051 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
2052
2053 return (map_aci_2_ati_rslt (ret));
2054 }
2055
2056 /*
2057 +--------------------------------------------------------------------+
2058 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2059 | STATE : code ROUTINE : atPlusCLCC |
2060 +--------------------------------------------------------------------+
2061
2062 PURPOSE : +CLCCcommand (list current calls)
2063 */
2064 GLOBAL T_ATI_RSLT setatPlusCLCC(char *cl, UBYTE srcId)
2065 {
2066 #ifdef FF_ATI_BAT
2067
2068 T_BAT_cmd_send cmd;
2069 T_BAT_no_parameter dummy;
2070 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CLCC;
2071 dummy.bat_dummy = 0xFF;
2072 cmd.params.ptr_que_plus_clcc = &dummy;
2073
2074 TRACE_FUNCTION("setatPlusCLCC() calls bat_send() <=== as APPLICATION");
2075
2076 bat_send(ati_bat_get_client(srcId), &cmd);
2077
2078 return (ATI_EXCT); /* executing, because response is passed by callback function */
2079
2080 #else /* no FF_ATI_BAT */
2081
2082 char *me = "+CLCC: ";
2083 T_ACI_CLCC_CALDESC *calLst = NULL;
2084 UBYTE lstIdx = 0;
2085 SHORT pos = 0;
2086 USHORT lenCvtdAlpha = 0;
2087 UBYTE type = 0;
2088
2089 CHAR cvtdAlpha[2*MAX_ALPHA_LEN];
2090
2091 TRACE_FUNCTION("setatPlusCLCC()");
2092
2093 srcId_cb = srcId; /* For utl_chsetFromGsm() */
2094 switch (*cl)
2095 {
2096 case(';'):
2097 case(0x0):
2098 {
2099 /* Check if we have enough RAM for the following ACI_MALLOC */
2100 USHORT free, alloc;
2101 int ret;
2102 ret = vsi_m_status ( hCommACI,
2103 MAX_CALL_NR * sizeof (T_ACI_CLCC_CALDESC),
2104 PRIM_POOL_PARTITION,
2105 &free,
2106 &alloc );
2107 if (ret EQ VSI_ERROR || free EQ 0)
2108 {
2109 cmdCmeError(CME_ERR_MemFull);
2110 return (ATI_FAIL);
2111 }
2112 }
2113 ACI_MALLOC (calLst, MAX_CALL_NR * sizeof (T_ACI_CLCC_CALDESC));
2114 (void)qAT_PlusCLCC((T_ACI_CMD_SRC)srcId, calLst); /* Always returns AT_CMPL */
2115
2116 /* 20 is approximatly the amount of extra characters (like ",") */
2117
2118 for( lstIdx = 0; lstIdx < MAX_CALL_NR; lstIdx++ )
2119 {
2120 if( calLst[lstIdx].idx EQ ACI_NumParmNotPresent )
2121 break;
2122
2123 pos = sprintf(g_sa,"%s%d",me,calLst[lstIdx].idx);
2124
2125 if (calLst[lstIdx].dir NEQ CLCC_DIR_NotPresent)
2126 pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].dir);
2127 else
2128 pos += sprintf(g_sa+pos,",");
2129 if (calLst[lstIdx].stat NEQ CLCC_STAT_NotPresent)
2130 pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].stat);
2131 else
2132 pos += sprintf(g_sa+pos,",");
2133 if (calLst[lstIdx].mode NEQ CLCC_MODE_NotPresent)
2134 pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].mode);
2135 else
2136 pos += sprintf(g_sa+pos,",");
2137 if (calLst[lstIdx].mpty NEQ CLCC_MPTY_NotPresent)
2138 pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].mpty);
2139 else
2140 pos += sprintf(g_sa+pos,",");
2141
2142 if (calLst[lstIdx].number[0] NEQ 0x0)
2143 {
2144 pos += sprintf(g_sa+pos,",\"%s\"",calLst[lstIdx].number);
2145 if (calLst[lstIdx].type.ton NEQ TON_NotPresent)
2146 {
2147 type = toa_merge(calLst[lstIdx].type);
2148 pos += sprintf(g_sa+pos,",%d",(int)type);
2149 }
2150 #ifdef NO_ASCIIZ
2151 if (calLst[lstIdx].alpha.len NEQ 0x0)
2152 {
2153 pos += sprintf(g_sa+pos,",");
2154 utl_chsetFromGsm ( calLst[lstIdx].alpha.data,
2155 calLst[lstIdx].alpha.len,
2156 (UBYTE*)cvtdAlpha,
2157 sizeof(cvtdAlpha),
2158 &lenCvtdAlpha,
2159 GSM_ALPHA_Def );
2160 pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha );
2161 }
2162 #else /* #ifdef NO_ASCIIZ */
2163 if (calLst[lstIdx].alpha[0] NEQ 0x0)
2164 {
2165 pos += sprintf(g_sa+pos,",");
2166 utl_chsetFromGsm ( (UBYTE*)calLst[lstIdx].alpha,
2167 0,
2168 (UBYTE*)cvtdAlpha,
2169 sizeof(cvtdAlpha),
2170 &lenCvtdAlpha,
2171 GSM_ALPHA_Int );
2172 pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha );
2173 }
2174 #endif /* #ifdef NO_ASCIIZ */
2175 }
2176
2177 ci_remTrailCom(g_sa, pos);
2178 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
2179 }
2180 ACI_MFREE (calLst);
2181 break;
2182 default:
2183 cmdCmeError(CME_ERR_Unknown);
2184 return (ATI_FAIL);
2185 }
2186 return (ATI_CMPL);
2187
2188 #endif /* no FF_ATI_BAT */
2189 }
2190
2191 /*
2192 +--------------------------------------------------------------------+
2193 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2194 | STATE : code ROUTINE : atPercentCLCC |
2195 +--------------------------------------------------------------------+
2196
2197 PURPOSE : %CLCCcommand (list current calls)
2198 */
2199 GLOBAL T_ATI_RSLT setatPercentCLCC(char *cl, UBYTE srcId)
2200 {
2201 char *me = "%CLCC: ";
2202 T_ACI_CLCC_CALDESC *calLst = NULL;
2203 UBYTE lstIdx = 0;
2204 SHORT pos = 0;
2205 USHORT lenCvtdAlpha = 0;
2206 UBYTE type = 0;
2207 CHAR cvtdAlpha[2*MAX_ALPHA_LEN];
2208
2209 TRACE_FUNCTION("setatPercentCLCC()");
2210
2211 srcId_cb = srcId; /* For utl_chsetFromGsm() */
2212
2213 switch (*cl)
2214 {
2215 case(';'):
2216 case(0x0):
2217 ACI_MALLOC (calLst, MAX_CALL_NR * sizeof (T_ACI_CLCC_CALDESC));
2218 memset(calLst, 0 , MAX_CALL_NR * sizeof (T_ACI_CLCC_CALDESC));
2219 (void)qAT_PlusCLCC((T_ACI_CMD_SRC)srcId, calLst); /* Always returns AT_CMPL */
2220
2221 /* 20 is approximatly the amount of extra characters (like ",") */
2222
2223 for( lstIdx = 0; lstIdx < MAX_CALL_NR; lstIdx++ )
2224 {
2225 if( calLst[lstIdx].idx EQ ACI_NumParmNotPresent )
2226 break;
2227
2228 pos = sprintf(g_sa,"%s%d",me,calLst[lstIdx].idx);
2229
2230 if (calLst[lstIdx].dir NEQ CLCC_DIR_NotPresent)
2231 pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].dir);
2232 else
2233 pos += sprintf(g_sa+pos,",");
2234 if (calLst[lstIdx].stat NEQ CLCC_STAT_NotPresent)
2235 pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].stat);
2236 else
2237 pos += sprintf(g_sa+pos,",");
2238 if (calLst[lstIdx].mode NEQ CLCC_MODE_NotPresent)
2239 pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].mode);
2240 else
2241 pos += sprintf(g_sa+pos,",");
2242 if (calLst[lstIdx].mpty NEQ CLCC_MPTY_NotPresent)
2243 pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].mpty);
2244 else
2245 pos += sprintf(g_sa+pos,",");
2246 if (calLst[lstIdx].class_type NEQ CLCC_CLASS_NotPresent)
2247 pos += sprintf(g_sa+pos,",%d",calLst[lstIdx].class_type);
2248 else
2249 pos += sprintf(g_sa+pos,",");
2250
2251 if (calLst[lstIdx].number[0] NEQ 0x0)
2252 {
2253 pos += sprintf(g_sa+pos,",\"%s\"",calLst[lstIdx].number);
2254 if (calLst[lstIdx].type.ton NEQ TON_NotPresent)
2255 {
2256 type = toa_merge(calLst[lstIdx].type);
2257 pos += sprintf(g_sa+pos,",%d",(int)type);
2258 }
2259 #ifdef NO_ASCIIZ
2260 if (calLst[lstIdx].alpha.len NEQ 0x0)
2261 {
2262 pos += sprintf(g_sa+pos,",");
2263 utl_chsetFromGsm ( calLst[lstIdx].alpha.data,
2264 calLst[lstIdx].alpha.len,
2265 (UBYTE*)cvtdAlpha,
2266 sizeof(cvtdAlpha),
2267 &lenCvtdAlpha,
2268 GSM_ALPHA_Def );
2269 pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha );
2270 }
2271 #else /* #ifdef NO_ASCIIZ */
2272 if (calLst[lstIdx].alpha[0] NEQ 0x0)
2273 {
2274 pos += sprintf(g_sa+pos,",");
2275 utl_chsetFromGsm ( (UBYTE*)calLst[lstIdx].alpha,
2276 0,
2277 (UBYTE*)cvtdAlpha,
2278 sizeof(cvtdAlpha),
2279 &lenCvtdAlpha,
2280 GSM_ALPHA_Int );
2281 pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha );
2282 }
2283 #endif /* #ifdef NO_ASCIIZ */
2284 }
2285
2286 ci_remTrailCom(g_sa, pos);
2287 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
2288 }
2289 ACI_MFREE (calLst);
2290 break;
2291 default:
2292 cmdCmeError(CME_ERR_Unknown);
2293 return (ATI_FAIL);
2294 }
2295 return (ATI_CMPL);
2296 }
2297
2298 /*
2299 +--------------------------------------------------------------------+
2300 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2301 | STATE : code ROUTINE : atPlusCCWA |
2302 +--------------------------------------------------------------------+
2303
2304 PURPOSE : +CCWA command (Call Waiting Managment)
2305 */
2306 GLOBAL T_ATI_RSLT setatPlusCCWA (char *cl, UBYTE srcId)
2307 {
2308 T_ACI_RETURN ret = AT_FAIL;
2309 T_ACI_CCWA_MOD mode = CCWA_MOD_NotInterrogate;
2310 T_ACI_CLASS class_type = CLASS_NotPresent;
2311 SHORT val = -1;
2312 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
2313
2314 cl = parse(cl, "rdd", &val, &mode, &class_type);
2315 if (!cl OR val > 1 )
2316 {
2317 cmdCmeError (CME_ERR_OpNotAllow);
2318 return (ATI_FAIL);
2319 }
2320
2321 if (val >= 0)
2322 {
2323 at.flags.CCWA_stat=(UBYTE) val;
2324 }
2325
2326 #ifdef FF_ATI_BAT
2327 {
2328 T_BAT_cmd_send cmd;
2329 T_BAT_cmd_set_plus_ccwa my_bat_set_plus_ccwa;
2330
2331 TRACE_FUNCTION("setatPLusCCWA() calls bat_send() <=== as APPLICATION");
2332
2333 memset(&my_bat_set_plus_ccwa, 0, sizeof(my_bat_set_plus_ccwa));
2334 cmd.ctrl_params = BAT_CMD_SET_PLUS_CCWA;
2335 cmd.params.ptr_set_plus_ccwa = &my_bat_set_plus_ccwa;
2336
2337 my_bat_set_plus_ccwa.mode = mode;
2338 my_bat_set_plus_ccwa.bearer_class = class_type;
2339 src_params->curAtCmd = AT_CMD_CCWA;
2340 bat_send(ati_bat_get_client(srcId), &cmd);
2341
2342 return ATI_EXCT; /* executing, because response is passed by callback function */
2343 }
2344 #else /* OLD FUNCTION BODY */
2345
2346 TRACE_FUNCTION("setatPLusCCWA()");
2347
2348 if (mode EQ CCWA_MOD_Query) /*query mode*/
2349 {
2350 ret = qAT_PlusCCWA ((T_ACI_CMD_SRC)srcId,class_type);
2351 switch (ret)
2352 {
2353 case AT_EXCT:
2354 src_params->curAtCmd = AT_CMD_CCWA;
2355 break;
2356
2357 default:
2358 cmdCmeError(CME_ERR_Unknown);
2359 break;
2360 }
2361 }
2362 else /*set mode*/
2363 {
2364 ret = sAT_PlusCCWA ((T_ACI_CMD_SRC)srcId,mode,class_type);
2365 switch (ret)
2366 {
2367 case AT_EXCT:
2368 break;
2369
2370 case AT_FAIL:
2371 case AT_BUSY:
2372 cmdCmeError (CME_ERR_Unknown);
2373 break;
2374 }
2375 }
2376 return (map_aci_2_ati_rslt (ret));
2377
2378 #endif /* no FF_ATI_BAT*/
2379 }
2380
2381
2382 GLOBAL T_ATI_RSLT queatPlusCCWA (CHAR *cl, UBYTE srcId)
2383 {
2384 TRACE_FUNCTION("queatPLusCCWA()");
2385
2386 resp_disp (srcId, cl,"b",&at.flags.CCWA_stat);
2387 return (ATI_CMPL);
2388 }
2389
2390 /*
2391 +--------------------------------------------------------------------+
2392 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2393 | STATE : code ROUTINE : atPlusVTS |
2394 +--------------------------------------------------------------------+
2395
2396 PURPOSE : +VTS command (send DTMF)
2397 */
2398 GLOBAL T_ATI_RSLT setatPlusVTS (char * cl, UBYTE srcId)
2399 {
2400 T_ACI_RETURN ret = AT_FAIL;
2401 SHORT duration = ACI_NumParmNotPresent;
2402 CHAR dtmf = '\0';
2403 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
2404
2405 if( *cl EQ '\0' )
2406 {
2407 cmdCmeError(CME_ERR_OpNotAllow);
2408 return (ATI_FAIL);
2409 }
2410
2411 cl = parse (cl, "ar", (ULONG)1, &dtmf, &duration);
2412 if (!cl)
2413 {
2414 cmdCmeError(CME_ERR_OpNotAllow);
2415 return (ATI_FAIL);
2416 }
2417
2418 #ifdef FF_ATI_BAT
2419 {
2420 T_BAT_cmd_send cmd;
2421 T_BAT_cmd_set_plus_vts my_bat_set_plus_vts;
2422
2423 TRACE_FUNCTION("setatPlusVTS() calls bat_send() <=== as APPLICATION");
2424
2425 memset(&my_bat_set_plus_vts, 0, sizeof(my_bat_set_plus_vts));
2426 cmd.ctrl_params = BAT_CMD_SET_PLUS_VTS;
2427 cmd.params.ptr_set_plus_vts = &my_bat_set_plus_vts;
2428
2429 my_bat_set_plus_vts.dtmf = dtmf;
2430 src_params->curAtCmd = AT_CMD_VTS;
2431 bat_send(ati_bat_get_client(srcId), &cmd);
2432
2433 return ATI_EXCT; /* executing, because response is passed by callback function */
2434 }
2435 #else /* OLD FUNCTION BODY */
2436
2437 TRACE_FUNCTION("setatPlusVTS()");
2438
2439 ret = sAT_PlusVTS((T_ACI_CMD_SRC)srcId,dtmf,VTS_MOD_Auto);
2440
2441 switch (ret)
2442 {
2443 case AT_EXCT:
2444 src_params->curAtCmd = AT_CMD_VTS;
2445 break;
2446
2447 case AT_FAIL:
2448 case AT_BUSY:
2449 cmdCmeError (CME_ERR_Unknown);
2450 break;
2451 }
2452 return (map_aci_2_ati_rslt (ret));
2453
2454 #endif /* no FF_ATI_BAT*/
2455 }
2456
2457 /*
2458 +--------------------------------------------------------------------+
2459 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2460 | STATE : code ROUTINE : setatPercentRDL |
2461 +--------------------------------------------------------------------+
2462
2463 PURPOSE : %RDL command (set redial mode)
2464 */
2465
2466 GLOBAL T_ATI_RSLT setatPercentRDL (char* cl, UBYTE srcId)
2467 {
2468 T_ACI_CC_REDIAL_MODE rdlmode = AUTOM_REP_NOT_PRESENT;
2469 T_ACI_CC_REDIAL_NOTIF usr_notif = NOTIF_NO_PRESENT;
2470 T_ACI_RETURN ret = AT_FAIL;
2471
2472 cl = parse(cl, "dd", &rdlmode, &usr_notif);
2473 if(!cl)
2474 {
2475 cmdCmeError(CME_ERR_OpNotAllow);
2476 return (ATI_FAIL);
2477 }
2478
2479 #ifdef FF_ATI_BAT
2480 {
2481 T_BAT_cmd_send cmd;
2482 T_BAT_cmd_set_percent_rdl my_bat_set_percent_rdl;
2483
2484 TRACE_FUNCTION("setatPercentRDL() calls bat_send() <=== as APPLICATION");
2485
2486 memset(&my_bat_set_percent_rdl, 0, sizeof(my_bat_set_percent_rdl));
2487 cmd.ctrl_params = BAT_CMD_SET_PERCENT_RDL;
2488 cmd.params.ptr_set_percent_rdl = &my_bat_set_percent_rdl;
2489
2490 my_bat_set_percent_rdl.mode = (T_BAT_percent_rdl_mode)&rdlmode;
2491
2492 bat_send(ati_bat_get_client(srcId), &cmd);
2493
2494 return ATI_EXCT; /* executing, because response is passed by callback function */
2495 }
2496 #else /* OLD FUNCTION BODY */
2497
2498 TRACE_FUNCTION("setatPercentRDL()");
2499
2500 ret = sAT_PercentRDL ((T_ACI_CMD_SRC)srcId, rdlmode, usr_notif);
2501
2502 if (ret NEQ AT_CMPL)
2503 {
2504 cmdCmeError(CME_ERR_OpNotAllow);
2505 }
2506 return (map_aci_2_ati_rslt (ret));
2507
2508 #endif /* no FF_ATI_BAT*/
2509 }
2510
2511 /*
2512 +--------------------------------------------------------------------+
2513 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2514 | STATE : code ROUTINE : queatPercentRDL |
2515 +--------------------------------------------------------------------+
2516
2517 PURPOSE : %RDL command (query redial mode)
2518 */
2519
2520 GLOBAL T_ATI_RSLT queatPercentRDL (char* cl, UBYTE srcId)
2521 {
2522 T_ACI_CC_REDIAL_MODE rdlmode = AUTOM_REP_NOT_PRESENT;
2523 T_ACI_CC_REDIAL_NOTIF usr_notif = NOTIF_NO_PRESENT;
2524 T_ACI_RETURN ret = AT_FAIL;
2525
2526 TRACE_FUNCTION("queatPercentRDL()");
2527
2528 ret = qAT_PercentRDL ((T_ACI_CMD_SRC)srcId,&rdlmode, &usr_notif);
2529
2530 if(ret EQ AT_CMPL)
2531 {
2532 resp_disp (srcId, cl,"bb",&rdlmode, &usr_notif);
2533 }
2534 else
2535 {
2536 cmdCmeError (CME_ERR_Unknown);
2537 }
2538 return (map_aci_2_ati_rslt (ret));
2539 }
2540
2541 #ifdef TI_PS_FF_AT_P_CMD_RDLB
2542 /*
2543 +--------------------------------------------------------------------+
2544 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2545 | STATE : code ROUTINE : setatPercentRDLB |
2546 +--------------------------------------------------------------------+
2547
2548 PURPOSE : %RDLB command (delete black list of redialling phone
2549 numbers)
2550 */
2551
2552 GLOBAL T_ATI_RSLT setatPercentRDLB (char* cl, UBYTE srcId)
2553 {
2554 T_ACI_RETURN ret = AT_FAIL;
2555 T_ACI_CC_REDIAL_NOTIF usr_notif = NOTIF_NO_PRESENT;
2556 T_ACI_CC_REDIAL_BLMODE blmode = BLMODE_NO_PRESENT;
2557
2558 cl = parse(cl, "dd", &blmode, &usr_notif);
2559 if(!cl)
2560 {
2561 cmdCmeError(CME_ERR_OpNotAllow);
2562 return (ATI_FAIL);
2563 }
2564
2565 #ifdef FF_ATI_BAT
2566 {
2567 T_BAT_cmd_send cmd;
2568 T_BAT_cmd_set_percent_rdlb my_bat_set_percent_rdlb;
2569
2570 TRACE_FUNCTION("setatPercentRDLB() calls bat_send() <=== as APPLICATION");
2571
2572 memset(&my_bat_set_percent_rdlb, 0, sizeof(my_bat_set_percent_rdlb));
2573 cmd.ctrl_params = BAT_CMD_SET_PERCENT_RDLB;
2574 cmd.params.ptr_set_percent_rdlb = &my_bat_set_percent_rdlb;
2575
2576 my_bat_set_percent_rdlb.mode = (T_BAT_percent_rdlb_mode)&blmode;
2577
2578 bat_send(ati_bat_get_client(srcId), &cmd);
2579
2580 return ATI_EXCT; /* executing, because response is passed by callback function */
2581 }
2582 #else /* OLD FUNCTION BODY */
2583
2584 TRACE_FUNCTION("setatPercentRDLB()");
2585
2586 ret = sAT_PercentRDLB((T_ACI_CMD_SRC)srcId, blmode, usr_notif);
2587
2588 if (ret NEQ AT_CMPL)
2589 {
2590 cmdCmeError(CME_ERR_OpNotAllow);
2591 }
2592 return (map_aci_2_ati_rslt (ret));
2593
2594 #endif /* no FF_ATI_BAT*/
2595 }
2596
2597 /*
2598 +--------------------------------------------------------------------+
2599 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2600 | STATE : code ROUTINE : queatPercentRDLB |
2601 +--------------------------------------------------------------------+
2602
2603 PURPOSE : %RDLB command (query black list of redialling phone
2604 numbers)
2605 */
2606
2607 GLOBAL T_ATI_RSLT queatPercentRDLB (char* cl, UBYTE srcId)
2608 {
2609 T_ACI_RETURN ret = AT_FAIL;
2610 T_ACI_CC_REDIAL_BLACKL blackl;
2611 T_ACI_CC_REDIAL_NOTIF usr_notif= NOTIF_NO_PRESENT;
2612 UBYTE i,j;
2613 UBYTE type;
2614
2615 TRACE_FUNCTION("queatPercentRDLB()");
2616
2617 memset(&blackl, 0, sizeof(T_ACI_CC_REDIAL_BLACKL));
2618
2619 ret = qAT_PercentRDLB ((T_ACI_CMD_SRC)srcId,&blackl,&usr_notif);
2620
2621 if(ret EQ AT_CMPL)
2622 {
2623 resp_disp (srcId, cl,"b", &usr_notif); /* output user notification state */
2624 for(i=0; i<blackl.blCount; i++) /* output black list */
2625 {
2626 type = (UBYTE)toa_merge(blackl.blNum[i].type);
2627 for(j=0; j<blackl.blNum[i].numb_len; j++)
2628 {
2629 blackl.blNum[i].number[j] = (blackl.blNum[i].number[j] | 0x30);
2630 }
2631 sprintf(g_sa,"%s:\"%s\",%d","%RDLB",blackl.blNum[i].number,
2632 (int)type);
2633 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
2634 }
2635 }
2636 else
2637 {
2638 cmdCmeError (CME_ERR_Unknown);
2639 }
2640 return (map_aci_2_ati_rslt (ret));
2641 }
2642 #endif /* TI_PS_FF_AT_P_CMD_RDLB */
2643 /*
2644 +--------------------------------------------------------------------+
2645 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2646 | STATE : code ROUTINE : atPercentVTS |
2647 +--------------------------------------------------------------------+
2648
2649 PURPOSE : %VTS command (send DTMF)
2650 */
2651 GLOBAL T_ATI_RSLT setatPercentVTS (char * cl, UBYTE srcId)
2652 {
2653 T_ACI_RETURN ret = AT_FAIL;
2654 CHAR dtmf = 0x0;
2655 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
2656 T_ACI_VTS_MOD mode = VTS_MOD_Auto;
2657
2658 if( *cl EQ '\0' )
2659 {
2660 cmdCmeError(CME_ERR_OpNotAllow);
2661 return (ATI_FAIL);
2662 }
2663
2664 cl = parse (cl, "ar", (ULONG)1, &dtmf, &mode);
2665
2666 if (!cl)
2667 {
2668 cmdCmeError(CME_ERR_OpNotAllow);
2669 return (ATI_FAIL);
2670 }
2671
2672 if (mode EQ VTS_MOD_NotPresent)
2673 {
2674 mode = VTS_MOD_Auto;
2675 }
2676
2677 #ifdef FF_ATI_BAT
2678 {
2679 T_BAT_cmd_send cmd;
2680 T_BAT_cmd_set_percent_vts my_bat_set_percent_vts;
2681
2682 TRACE_FUNCTION("setatPercentVTS() calls bat_send() <=== as APPLICATION");
2683
2684 memset(&my_bat_set_percent_vts, 0, sizeof(my_bat_set_percent_vts));
2685 cmd.ctrl_params = BAT_CMD_SET_PERCENT_VTS;
2686 cmd.params.ptr_set_percent_vts = &my_bat_set_percent_vts;
2687
2688 my_bat_set_percent_vts.dtmf = dtmf;
2689 my_bat_set_percent_vts.mode = mode;
2690 src_params->curAtCmd = AT_CMD_VTS;
2691 bat_send(ati_bat_get_client(srcId), &cmd);
2692
2693 return ATI_EXCT; /* executing, because response is passed by callback function */
2694 }
2695 #else /* OLD FUNCTION BODY */
2696
2697 TRACE_FUNCTION("setatPercentVTS()");
2698
2699 ret = sAT_PlusVTS((T_ACI_CMD_SRC)srcId,dtmf,mode);
2700
2701 switch (ret)
2702 {
2703 case AT_EXCT:
2704 {
2705 src_params->curAtCmd = AT_CMD_VTS;
2706 break;
2707 }
2708 case AT_FAIL:
2709 case AT_BUSY:
2710 {
2711 cmdCmeError (CME_ERR_Unknown);
2712 break;
2713 }
2714 }
2715
2716 return (map_aci_2_ati_rslt (ret));
2717
2718 #endif /* no FF_ATI_BAT*/
2719 }
2720
2721
2722 /*
2723 +--------------------------------------------------------------------+
2724 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2725 | STATE : code ROUTINE : atPlusCSNS |
2726 +--------------------------------------------------------------------+
2727
2728 PURPOSE : +CSNS command (single numbering scheme)
2729 */
2730 GLOBAL T_ATI_RSLT setatPlusCSNS (char* cl, UBYTE srcId)
2731 {
2732 T_ACI_CSNS_MOD mode = CSNS_MOD_NotPresent;
2733 T_ACI_RETURN ret = AT_FAIL;
2734
2735 cl= parse (cl, "d", &mode);
2736 if (!cl)
2737 {
2738 cmdCmeError(CME_ERR_OpNotAllow);
2739 return (ATI_FAIL);
2740 }
2741
2742 #ifdef FF_ATI_BAT
2743 {
2744 T_BAT_cmd_send cmd;
2745 T_BAT_cmd_set_plus_csns my_bat_set_plus_csns;
2746
2747 TRACE_FUNCTION("setatPlusCSNS() calls bat_send() <=== as APPLICATION");
2748
2749 memset(&my_bat_set_plus_csns, 0, sizeof(my_bat_set_plus_csns));
2750 cmd.ctrl_params = BAT_CMD_SET_PLUS_CSNS;
2751 cmd.params.ptr_set_plus_csns = &my_bat_set_plus_csns;
2752
2753 my_bat_set_plus_csns.mode = mode;
2754
2755 bat_send(ati_bat_get_client(srcId), &cmd);
2756
2757 return ATI_EXCT; /* executing, because response is passed by callback function */
2758 }
2759 #else /* OLD FUNCTION BODY */
2760
2761 TRACE_FUNCTION("setatPlusCSNS()");
2762
2763 ret = sAT_PlusCSNS ((T_ACI_CMD_SRC)srcId, mode);
2764 if (ret NEQ AT_CMPL)
2765 {
2766 cmdCmeError(CME_ERR_OpNotAllow);
2767 }
2768 return (map_aci_2_ati_rslt (ret));
2769
2770 #endif /* no FF_ATI_BAT*/
2771 }
2772
2773 GLOBAL T_ATI_RSLT queatPlusCSNS (char* cl, UBYTE srcId)
2774 {
2775 T_ACI_CSNS_MOD mode = CSNS_MOD_NotPresent;
2776 T_ACI_RETURN ret = AT_FAIL;
2777
2778 TRACE_FUNCTION("queatPlusCSNS()");
2779
2780 ret = qAT_PlusCSNS ((T_ACI_CMD_SRC)srcId,&mode);
2781
2782 if(ret EQ AT_CMPL)
2783 {
2784 resp_disp (srcId, cl,"e",&mode);
2785 }
2786 else
2787 {
2788 cmdCmeError (CME_ERR_Unknown);
2789 }
2790 return (map_aci_2_ati_rslt (ret));
2791 }
2792 #ifdef TI_PS_FF_AT_CMD_P_ECC
2793 /*
2794 +--------------------------------------------------------------------+
2795 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2796 | STATE : code ROUTINE : setatPercentECC |
2797 +--------------------------------------------------------------------+
2798
2799 PURPOSE : %ECC command (set additional ECC numbers)
2800 */
2801
2802 GLOBAL T_ATI_RSLT setatPercentECC (char* cl, UBYTE srcId)
2803 {
2804 T_ACI_RETURN ret = AT_FAIL;
2805 U8 index;
2806 char ecc_number[ADDITIONAL_ECC_NUMBER_LENGTH+1]; /* +1 for '\0' */
2807 UBYTE idx;
2808 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
2809
2810 TRACE_FUNCTION("setatPercentECC()");
2811
2812 memset(ecc_number,0,sizeof(ecc_number));
2813
2814 cl = parse(cl,"ds",
2815 &index,
2816 (LONG)sizeof(ecc_number),
2817 ecc_number);
2818
2819 if (cl EQ NULL)
2820 {
2821 idx = get_parse_index(); /* get the problematic component */
2822 TRACE_EVENT_P1("index %d",idx);
2823 switch (idx)
2824 {
2825 case 1:
2826 cmdCmeError(CME_ERR_InvIdx);
2827 break;
2828 case 2:
2829 cmdCmeError(CME_ERR_TxtToLong);
2830 break;
2831 default:
2832 cmdCmeError(CME_ERR_OpNotAllow);
2833 break;
2834 }
2835 return ATI_FAIL;
2836 }
2837
2838 #ifdef FF_ATI_BAT
2839 {
2840 T_BAT_cmd_send cmd;
2841 T_BAT_cmd_set_percent_ecc ecc;
2842
2843 memset(&ecc, 0, sizeof(ecc));
2844 cmd.ctrl_params = BAT_CMD_SET_PERCENT_ECC;
2845 cmd.params.ptr_set_percent_ecc = &ecc;
2846 ecc.index = index;
2847 ecc.c_number = (U8)strlen(ecc_number);
2848 memcpy(ecc.number, ecc_number, ecc.c_number);
2849 src_params->curAtCmd = AT_CMD_P_ECC;
2850 bat_send(ati_bat_get_client(srcId), &cmd);
2851
2852 return ATI_EXCT;
2853 }
2854 #else
2855 ret = sAT_PercentECC((T_ACI_CMD_SRC)srcId, index, ecc_number);
2856
2857 return (map_aci_2_ati_rslt(ret));
2858 #endif
2859 }
2860 #endif /* TI_PS_FF_AT_CMD_P_ECC */
2861
2862 /*
2863 +--------------------------------------------------------------------+
2864 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2865 | STATE : code ROUTINE : setatPlusCVHU |
2866 +--------------------------------------------------------------------+
2867
2868 PURPOSE : +CVHU command (set voice hangup control)
2869 */
2870 GLOBAL T_ATI_RSLT setatPlusCVHU (char* cl, UBYTE srcId)
2871 {
2872 T_ACI_CVHU_MODE mode = CVHU_DropDTR_IGNORED;
2873 T_ACI_RETURN ret = AT_FAIL;
2874 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
2875
2876 TRACE_FUNCTION("setatPlusCVHU()");
2877
2878 cl= parse (cl,"d",&mode);
2879 if(!cl)
2880 {
2881 cmdCmeError(CME_ERR_OpNotAllow);
2882 return (ATI_FAIL);
2883 }
2884 #ifdef FF_ATI_BAT
2885 {
2886 T_BAT_cmd_send cmd;
2887 T_BAT_cmd_set_plus_cvhu cvhu;
2888
2889 memset(&cvhu, 0, sizeof(cvhu));
2890 cmd.ctrl_params = BAT_CMD_SET_PLUS_CVHU;
2891 cmd.params.ptr_set_plus_cvhu = &cvhu;
2892 cvhu.cvhu_mode = mode;
2893 src_params->curAtCmd = AT_CMD_CVHU;
2894 bat_send(ati_bat_get_client(srcId), &cmd);
2895
2896 return ATI_EXCT;
2897 }
2898 #else
2899 ret= sAT_PlusCVHU ((T_ACI_CMD_SRC)srcId, mode);
2900 if (ret NEQ AT_CMPL)
2901 {
2902 cmdCmeError(CME_ERR_OpNotAllow);
2903 }
2904 return (map_aci_2_ati_rslt (ret));
2905 #endif
2906 }
2907
2908 /*
2909 +--------------------------------------------------------------------+
2910 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2911 | STATE : code ROUTINE : queatPlusCVHU |
2912 +--------------------------------------------------------------------+
2913
2914 PURPOSE : +CVHU command (query voice hangup control)
2915 */
2916 GLOBAL T_ATI_RSLT queatPlusCVHU (char* cl, UBYTE srcId)
2917 {
2918 T_ACI_CVHU_MODE mode = CVHU_DropDTR_IGNORED;
2919 T_ACI_RETURN ret = AT_FAIL;
2920 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
2921
2922 TRACE_FUNCTION("queatPlusCVHU()");
2923
2924 #ifdef FF_ATI_BAT
2925 {
2926 T_BAT_cmd_send cmd;
2927 T_BAT_no_parameter dummy;
2928
2929 TRACE_FUNCTION("queatPlusCVHU() calls bat_send() <=== as APPLICATION");
2930
2931 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CVHU;
2932 dummy.bat_dummy = 0xFF;
2933 cmd.params.ptr_que_plus_cvhu = &dummy;
2934 src_params->curAtCmd = AT_CMD_CVHU;
2935 bat_send(ati_bat_get_client(srcId), &cmd);
2936 return ATI_EXCT; /* executing, because response is passed by callback function */
2937 }
2938 #else /* no FF_ATI_BAT */
2939 ret = qAT_PlusCVHU ((T_ACI_CMD_SRC)srcId, &mode);
2940
2941 if(ret EQ AT_CMPL)
2942 {
2943 resp_disp (srcId, cl, "e", &mode);
2944 }
2945 else
2946 {
2947 cmdCmeError (CME_ERR_Unknown);
2948 }
2949 return (map_aci_2_ati_rslt (ret));
2950 #endif /* FF_ATI_BAT */
2951 }
2952 #endif /* ATI_CC_C */
2953