FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/ati_sim.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: SIM related functions.
18 +-----------------------------------------------------------------------------
19 */
20
21 #ifndef ATI_SIM_C
22 #define ATI_SIM_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_cmh.h"
34 #include "ati_cmd.h"
35 #include "aci_io.h"
36 #include "aci_cmd.h"
37 #include "l4_tim.h"
38
39 #include "gdi.h"
40 #include "audio.h"
41
42 #include "aci_mem.h"
43 #include "aci_ext_pers.h"
44 #include "aci_slock.h"
45 #include "aci_prs.h"
46 #include "aci_lst.h"
47 #include "ati_int.h"
48
49 #ifdef FF_ATI_BAT
50
51 #include "typedefs.h"
52 #include "gdd.h"
53 #include "bat.h"
54
55 #include "ati_bat.h"
56
57 #endif /* FF_ATI_BAT */
58
59 /*==== EXPORT ==================================================*/
60
61 EXTERN CHAR *cmdExtError (T_ACI_EXT_ERR e);
62
63 #ifdef TI_PS_FF_AT_P_CMD_SECP
64 /*
65 +--------------------------------------------------------------------+
66 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
67 | STATE : code ROUTINE : setatPercentSECP |
68 +--------------------------------------------------------------------+
69
70 PURPOSE : %SECP command (PIN functionality for MMI Security)
71 */
72
73 GLOBAL T_ATI_RSLT setatPercentSECP(CHAR * cl, UBYTE srcId)
74 {
75 char pinOld [MAX_PWD_LENGTH]={0};
76 char pinNew [MAX_PWD_LENGTH]={0};
77 T_ACI_RETURN ret = AT_FAIL;
78
79 TRACE_FUNCTION ("setatPercentSECP()");
80
81 cl = parse(cl, "nn", (LONG)MAX_PWD_LENGTH, pinOld,(LONG)MAX_PWD_LENGTH, pinNew);
82 if ( !cl OR (*pinOld EQ '\0' AND *pinNew EQ '\0') )
83 {
84 cmdCmeError(CME_ERR_OpNotAllow);
85 return ATI_FAIL;
86 }
87
88 ret = sAT_PercentSECP((T_ACI_CMD_SRC)srcId, pinOld, pinNew);
89
90 return (map_aci_2_ati_rslt(ret));
91 }
92 #endif /* TI_PS_FF_AT_P_CMD_SECP */
93
94 #ifdef TI_PS_FF_AT_P_CMD_SECS
95 /*
96 +--------------------------------------------------------------------+
97 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
98 | STATE : code ROUTINE : setatPercentSECS |
99 +--------------------------------------------------------------------+
100
101 PURPOSE : %SECS command (This function changes the state of the MMI Security code
102 It requires the existing security code as one of the parameters)
103 */
104
105
106 GLOBAL T_ATI_RSLT setatPercentSECS (CHAR *cl, UBYTE srcId)
107 {
108 char code [MAX_PWD_LENGTH]={0};
109 T_ACI_SECS_STA securityState = SECS_STA_NotPresent;
110 T_ACI_RETURN ret = AT_FAIL;
111
112
113 TRACE_FUNCTION ("setatPercentSECS()");
114
115 /* Get the required state and the Security code from the command parameters*/
116 cl = parse(cl, "dn", &securityState, (LONG)MAX_PWD_LENGTH, code);
117
118 if ( !cl OR *code EQ '\0' )
119 {
120 cmdCmeError(CME_ERR_OpNotAllow);
121 return ATI_FAIL;
122 }
123
124 ret = sAT_PercentSECS((T_ACI_CMD_SRC)srcId,securityState,code);
125 return (map_aci_2_ati_rslt(ret));
126
127
128 }
129
130
131 /*
132 +--------------------------------------------------------------------+
133 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
134 | STATE : code ROUTINE : qetatPercentSECS |
135 +--------------------------------------------------------------------+
136
137 PURPOSE : %SECS? command (It queries the state of the MMI Security code)
138 */
139
140
141 GLOBAL T_ATI_RSLT quetatPercentSECS (CHAR *cl, UBYTE srcId)
142 {
143 T_ACI_SECS_STA securityState = SECS_STA_NotPresent;
144 T_ACI_RETURN ret = AT_FAIL;
145
146
147 TRACE_FUNCTION ("qetatPercentSECS()");
148
149 /* Get the State value from the Command Handler */
150 ret = qAT_PercentSECS((T_ACI_CMD_SRC)srcId, &securityState);
151
152 if (ret EQ AT_CMPL)
153 {
154 resp_disp(srcId, cl,"e",&securityState);
155 return ATI_CMPL;
156 }
157 else
158 {
159 cmdCmeError(CME_ERR_Unknown);
160 return ATI_FAIL;
161 }
162
163
164 }
165 #endif /* TI_PS_FF_AT_P_CMD_SECS */
166
167
168 GLOBAL CHAR *CPIN_RESULT(T_ACI_CPIN_RSLT code)
169 {
170 switch (code)
171 {
172 default:
173 case(CPIN_RSLT_NotPresent): return"not present";
174 case(CPIN_RSLT_SimReady): return"READY";
175 case(CPIN_RSLT_SimPinReq): return"SIM PIN";
176 case(CPIN_RSLT_SimPukReq): return"SIM PUK";
177 case(CPIN_RSLT_PhSimPinReq):return"PH-SIM PIN";
178 case(CPIN_RSLT_SimPin2Req): return"SIM PIN2";
179 case(CPIN_RSLT_SimPuk2Req): return"SIM PUK2";
180 /* OVK: Extended list of all possible result according to 07.07 */
181 case(CPIN_RSLT_PhFSimPinReq): return"PH-FSIM PIN";
182 case(CPIN_RSLT_PhFSimPukReq): return"PH-FSIM PUK";
183 case(CPIN_RSLT_PhNetPinReq): return"PH-NET PIN";
184 case(CPIN_RSLT_PhNetPukReq): return"PH_NET PUK";
185 case(CPIN_RSLT_PhNetSubPinReq): return"PH-NETSUB PIN";
186 case(CPIN_RSLT_PhNetSubPukReq): return"PH-NETSUB PUK";
187 case(CPIN_RSLT_PhSPPinReq): return"PH-SP PIN";
188 case(CPIN_RSLT_PhSPPukReq): return"PH-SP PUK";
189 case(CPIN_RSLT_PhCorpPinReq): return"PH-CORP PIN";
190 case(CPIN_RSLT_PhCorpPukReq): return"PH-CORP PUK";
191
192
193 }
194 }
195
196 /*
197 +--------------------------------------------------------------------+
198 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
199 | STATE : code ROUTINE : atPlusCPIN |
200 +--------------------------------------------------------------------+
201
202 PURPOSE : +CPIN command (PIN functionality of ME)
203 */
204
205 GLOBAL T_ATI_RSLT setatPlusCPIN (char *cl, UBYTE srcId)
206 {
207 char pinOld [MAX_PWD_LENGTH]={0}; /* ES!! enough for bad guys?*/
208 char pinNew [MAX_PWD_LENGTH]={0};
209 T_ACI_RETURN ret = AT_FAIL;
210 UBYTE slockBlocked = 0; /* @GBR: AT_CMPL is interpreted as error per default. This is wrong, if the ME is SIMLOCKed */
211
212 TRACE_FUNCTION ("setatPlusCPIN()");
213
214 cl = parse(cl,"nn",(LONG)MAX_PWD_LENGTH,&pinOld,(LONG)MAX_PWD_LENGTH,&pinNew);
215 if ( !cl OR *pinOld EQ '\0' )
216 {
217 cmdCmeError(CME_ERR_OpNotAllow);
218 return ATI_FAIL;
219 }
220 #ifdef SIM_PERS
221 slockBlocked = AciSLockShrd.blocked;
222 #endif
223 #ifdef FF_ATI_BAT
224 {
225 T_BAT_cmd_send cmd;
226 T_BAT_cmd_set_plus_cpin my_bat_set_plus_cpin = {0};
227 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
228
229 TRACE_FUNCTION("setatPlusCPIN() calls bat_send() <=== as APPLICATION");
230
231 /* memset(&my_bat_set_plus_cpin, FALSE, sizeof(my_bat_set_plus_cpin)); Already initilaised */
232 cmd.ctrl_params = BAT_CMD_SET_PLUS_CPIN;
233 cmd.params.ptr_set_plus_cpin = &my_bat_set_plus_cpin;
234
235 /* Set old pin BAT attribs */
236 my_bat_set_plus_cpin.c_pin = strlen(pinOld);
237 memcpy(my_bat_set_plus_cpin.pin, pinOld, BAT_MAX_CPIN_PIN_LEN);
238
239 /* Set new pin BAT attribs */
240 if(my_bat_set_plus_cpin.c_newpin = strlen(pinNew))
241 {
242 my_bat_set_plus_cpin.v_newpin = TRUE;
243 memcpy(my_bat_set_plus_cpin.pin, pinNew, BAT_MAX_CPIN_PIN_LEN);
244 }
245
246 src_params->curAtCmd = AT_CMD_CPIN;
247
248 bat_send(ati_bat_get_client(srcId), &cmd);
249 return ATI_EXCT; /* executing, because response is passed by callback function */
250 }
251
252 #else /* no FF_ATI_BAT */
253
254 TRACE_FUNCTION("setatPlusCPIN()");
255 ret = sAT_PlusCPIN ((T_ACI_CMD_SRC)srcId,pinOld,pinNew);
256
257 switch(ret)
258 {
259 case(AT_EXCT):
260 {
261 break;
262 }
263 case(AT_BUSY):
264 {
265 cmdCmeError(CME_ERR_SimBusy);
266 break;
267 }
268 case(AT_FAIL):
269 {
270 cmdCmeError(CME_ERR_Unknown);
271 break;
272 }
273 case(AT_CMPL):
274 {
275 if (!slockBlocked)
276 {
277 cmdCmeError(CME_ERR_Unknown);
278 }
279 break;
280 }
281 }
282 return (map_aci_2_ati_rslt(ret));
283 #endif /* FF_ATI_BAT */
284 }
285
286 GLOBAL T_ATI_RSLT queatPlusCPIN (char *cl, UBYTE srcId)
287 {
288 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
289 src_params->curAtCmd = AT_CMD_CPIN;
290
291 #ifdef FF_ATI_BAT
292 {
293 T_BAT_cmd_send cmd;
294 T_BAT_no_parameter dummy;
295
296 TRACE_FUNCTION("queatPlusCPIN() calls bat_send() <=== as APPLICATION");
297
298 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CPIN;
299 dummy.bat_dummy = 0xFF;
300 cmd.params.ptr_que_plus_cpin = &dummy;
301 bat_send(ati_bat_get_client(srcId), &cmd);
302 return ATI_EXCT; /* executing, because response is passed by callback function */
303 }
304 #else /* no FF_ATI_BAT */
305 {
306 T_ACI_RETURN ret = AT_FAIL;
307 T_ACI_CPIN_RSLT code;
308
309 TRACE_FUNCTION ("queatPlusCPIN()");
310
311 ret= qAT_PlusCPIN ((T_ACI_CMD_SRC)srcId,&code); /*PIN status is requested*/
312 switch (ret)
313 {
314 case(AT_CMPL):
315 {
316 sprintf (g_sa,"+CPIN: %s",CPIN_RESULT(code));
317 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT);
318 break;
319 }
320 case(AT_EXCT):
321 {
322 src_params->curAtCmd = AT_CMD_CPIN;
323 break;
324 }
325 default:
326 {
327 cmdCmeError (CME_ERR_Unknown);
328 break;
329 }
330 }
331 return (map_aci_2_ati_rslt(ret));
332 }
333 #endif /* no FF_ATI_BAT */
334 }
335
336 /*
337 +--------------------------------------------------------------------+
338 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
339 | STATE : code ROUTINE : atPlusCPOL |
340 +--------------------------------------------------------------------+
341
342 PURPOSE : +CPOL command (preferred operator list)
343 */
344
345 GLOBAL T_ATI_RSLT setatPlusCPOL (char *cl, UBYTE srcId)
346 {
347 T_ACI_CPOL_FRMT format = CPOL_FRMT_NotPresent;
348 SHORT index = ACI_NumParmNotPresent;
349 char op[20] = {0};
350 T_ACI_RETURN ret = AT_FAIL;
351 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
352
353 TRACE_FUNCTION("setatPlusCPOL()");
354
355 cl = parse(cl,"dds",&index,&format,(LONG)20,op);
356 if(!cl)
357 {
358 cmdCmeError(CME_ERR_OpNotAllow);
359 return ATI_FAIL;
360 }
361
362 #ifdef FF_ATI_BAT
363
364 {
365 T_BAT_cmd_send cmd;
366 T_BAT_cmd_set_plus_cpol cpol;
367 UBYTE len;
368
369 len=strlen(op);
370
371 /*
372 * If the operator name is too big for the BAT structure, there's
373 * nothing we can do. A truncated version would be meaningless, and
374 * to omit it would result in an operator being deleted from the
375 * list.
376 */
377 if (len>BAT_MAX_CPOL_OPER_LEN)
378 return(ATI_FAIL);
379
380 cmd.ctrl_params = BAT_CMD_SET_PLUS_CPOL;
381 cmd.params.ptr_set_plus_cpol=&cpol;
382
383 cpol.index=(S16)index;
384
385 /*
386 * This relies on T_ACI_CPOL_FRMT being identical to
387 * T_BAT_plus_cpol_format.
388 */
389 cpol.format=(T_BAT_plus_cpol_format)format;
390
391 if (len>0)
392 {
393 memcpy(cpol.oper,op,len);
394 cpol.v_oper=TRUE;
395 cpol.c_oper=(U8)len;
396 }
397 else
398 {
399 cpol.v_oper=FALSE;
400 }
401
402 bat_send(ati_bat_get_client(srcId), &cmd);
403 src_params->curAtCmd=AT_CMD_CPOL;
404 return(ATI_EXCT);
405 }
406
407 #else /* no FF_ATI_BAT */
408
409 #ifdef WIN32
410 ret=sAT_PlusCPOL(srcId,index,format,
411 ((op[0] NEQ 0x0)?op:NULL),
412 cpolIdx2,
413 cpolMode);
414 #else
415 ret=sAT_PlusCPOL((T_ACI_CMD_SRC)srcId,index,format,
416 ((op[0] NEQ 0x0)?op:NULL),
417 ACI_NumParmNotPresent,
418 CPOL_MOD_NotPresent);
419 #endif
420
421
422 switch (ret)
423 {
424 case (AT_CMPL):
425 return ATI_CMPL;
426 case (AT_EXCT):
427 src_params->curAtCmd = AT_CMD_CPOL;
428 return ATI_EXCT;
429 default:
430 cmdCmeError(CME_ERR_Unknown);
431 return ATI_FAIL;
432 }
433 #endif /* no FF_ATI_BAT */
434 }
435
436 GLOBAL T_ATI_RSLT tesatPlusCPOL (char *cl, UBYTE srcId)
437 {
438 SHORT lastIdx=0,usdNtry=0;
439 T_ACI_RETURN ret = AT_FAIL;
440 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
441
442 TRACE_FUNCTION("tesatPlusCPOL()");
443
444 src_params->curAtCmd=AT_CMD_CPOL;
445
446 #ifdef FF_ATI_BAT
447 {
448 T_BAT_cmd_send cmd;
449 T_BAT_no_parameter dummy;
450
451 cmd.ctrl_params = BAT_CMD_TST_PLUS_CPOL;
452 dummy.bat_dummy = 0xFF;
453 cmd.params.ptr_tst_plus_cpol = &dummy;
454 bat_send(ati_bat_get_client(srcId), &cmd);
455 return(ATI_EXCT);
456 }
457 #else /* no FF_ATI_BAT */
458
459 ret = tAT_PlusCPOL((T_ACI_CMD_SRC)srcId,&lastIdx,&usdNtry);
460 if (ret EQ AT_CMPL)
461 {
462 sprintf(g_sa,"+CPOL: (1-%d),(0-2)", lastIdx);
463 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
464 }
465 if (ret EQ AT_EXCT)
466 {
467 src_params->curAtCmd = AT_CMD_CPOL;
468 }
469 if (ret EQ AT_FAIL)
470 {
471 cmdCmeError(CME_ERR_Unknown);
472 }
473 return (map_aci_2_ati_rslt(ret));
474
475 #endif /* no FF_ATI_BAT */
476 }
477
478 GLOBAL T_ATI_RSLT queatPlusCPOL (char *cl, UBYTE srcId)
479 {
480 #ifndef FF_ATI_BAT
481 T_ACI_CPOL_LST plmnSelLst;
482 UBYTE idx;
483 BOOL loop;
484 #endif
485
486 SHORT startIdx=0,lastIdx=0;
487 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
488
489 src_params->curAtCmd=AT_CMD_CPOL;
490
491 TRACE_FUNCTION("queatPlusCPOL()");
492
493 #ifdef FF_ATI_BAT
494 {
495 T_BAT_cmd_send cmd;
496 T_BAT_no_parameter dummy;
497
498 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CPOL;
499 dummy.bat_dummy = 0xFF;
500 cmd.params.ptr_que_plus_cpol = &dummy;
501 bat_send(ati_bat_get_client(srcId), &cmd);
502 return(ATI_EXCT);
503 }
504 #else /* no FF_ATI_BAT */
505
506 #ifdef WIN32
507 switch (qAT_PlusCPOL ( srcId,
508 1, &lastIdx,
509 &plmnSelLst[0],
510 cpolMode))
511 #else
512 switch (qAT_PlusCPOL ( (T_ACI_CMD_SRC)srcId,
513 1, &lastIdx,
514 &plmnSelLst[0],
515 CPOL_MOD_NotPresent))
516 #endif
517 {
518 case AT_CMPL:
519 loop = TRUE;
520 do
521 {
522 if( lastIdx EQ ACI_NumParmNotPresent )
523 break;
524
525 startIdx = lastIdx+1;
526
527 for( idx=0; idx < MAX_OPER; idx++ )
528 {
529 if( plmnSelLst[idx].index EQ ACI_NumParmNotPresent )
530 {
531 loop = FALSE;
532 break;
533 }
534 sprintf(g_sa,"+CPOL: %d,%d,\"%s\"", plmnSelLst[idx].index,
535 plmnSelLst[idx].format,
536 plmnSelLst[idx].oper );
537 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
538 }
539
540 if( qAT_PlusCPOL((T_ACI_CMD_SRC)srcId, startIdx, &lastIdx, &plmnSelLst[0],
541 #ifdef WIN32
542 cpolMode
543 #else
544 CPOL_MOD_NotPresent
545 #endif
546 ) EQ AT_FAIL OR !loop)
547 {
548 break;
549 }
550 }
551 while( loop );
552 return ATI_CMPL;
553
554 case AT_EXCT:
555 src_params->curAtCmd = AT_CMD_CPOL;
556 return ATI_EXCT;
557
558 default:
559 cmdCmeError(CME_ERR_Unknown);
560 return ATI_FAIL;
561 }
562
563 #endif /* no FF_ATI_BAT */
564 }
565
566 /*
567 +--------------------------------------------------------------------+
568 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
569 | STATE : code ROUTINE : atPlusCNUM |
570 +--------------------------------------------------------------------+
571
572 PURPOSE : +CNUM command (subscriber number)
573 */
574
575 GLOBAL T_ATI_RSLT setatPlusCNUM (char *cl, UBYTE srcId)
576 {
577 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
578 TRACE_FUNCTION("setatPlusCNUM()");
579
580 #ifdef FF_ATI_BAT
581
582 {
583 T_BAT_cmd_send cmd;
584 T_BAT_no_parameter dummy;
585
586 TRACE_FUNCTION("setatPlusCNUM() calls bat_send() <=== as APPLICATION");
587
588 cmd.ctrl_params = BAT_CMD_SET_PLUS_CNUM;
589 dummy.bat_dummy = 0xFF;
590 cmd.params.ptr_set_plus_cnum = &dummy;
591
592 bat_send(ati_bat_get_client(srcId), &cmd);
593
594 src_params->curAtCmd=AT_CMD_CNUM;
595 return(ATI_EXCT);
596 }
597
598 #else /* no FF_ATI_BAT */
599
600 if ( qAT_PlusCNUM ( (T_ACI_CMD_SRC)srcId, CNUM_MOD_NewRead ) EQ AT_EXCT )
601 {
602 src_params->curAtCmd = AT_CMD_CNUM;
603 return ATI_EXCT;
604 }
605 else
606 {
607 cmdCmeError ( CME_ERR_Unknown );
608 return ATI_FAIL;
609 }
610
611 #endif /* no FF_ATI_BAT */
612 }
613
614
615 /*
616 +--------------------------------------------------------------------+
617 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
618 | STATE : code ROUTINE : atPlusCFUN |
619 +--------------------------------------------------------------------+
620
621 PURPOSE : +CFUN command (Phone functionality)
622 */
623
624 GLOBAL T_ATI_RSLT setatPlusCFUN (char *cl, UBYTE srcId)
625 {
626 T_ACI_RETURN ret = AT_FAIL;
627 T_ACI_CFUN_FUN fun = CFUN_FUN_NotPresent;
628 T_ACI_CFUN_RST rst = CFUN_RST_NotPresent;
629 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
630
631 src_params->curAtCmd = AT_CMD_CFUN;
632
633 cl = parse (cl, "dd", &fun, &rst);
634 if ( !cl )
635 {
636 cmdCmeError (CME_ERR_OpNotAllow);
637 return (ATI_FAIL);
638 }
639
640 #ifdef FF_ATI_BAT
641 {
642 T_BAT_cmd_send cmd;
643 T_BAT_cmd_set_plus_cfun my_bat_set_plus_cfun;
644
645 TRACE_FUNCTION("setatPlusCFUN() calls bat_send() <=== as APPLICATION");
646
647 memset(&my_bat_set_plus_cfun, FALSE, sizeof(my_bat_set_plus_cfun));
648 cmd.ctrl_params = BAT_CMD_SET_PLUS_CFUN;
649 cmd.params.ptr_set_plus_cfun = &my_bat_set_plus_cfun;
650
651 my_bat_set_plus_cfun.fun = (T_BAT_VAL_plus_cfun_fun)fun;
652 my_bat_set_plus_cfun.rst = (T_BAT_VAL_plus_cfun_rst)rst;
653
654
655 bat_send(ati_bat_get_client(srcId), &cmd);
656 return ATI_EXCT; /* executing, because response is passed by callback function */
657 }
658 #else /* no FF_ATI_BAT */
659 {
660 TRACE_FUNCTION("setatPlusCFUN()");
661 ret = sAT_PlusCFUN ((T_ACI_CMD_SRC)srcId,fun,rst);
662 switch (ret)
663 {
664 case AT_EXCT: /*Command is executing*/
665 audio_SetAmplf (AUDIO_MICROPHONE, (UBYTE)75);
666 audio_SetAmplf (AUDIO_SPEAKER, (UBYTE)175);
667 src_params->curAtCmd = AT_CMD_CFUN;
668 break;
669
670 case AT_CMPL:
671 src_params->curAtCmd = AT_CMD_NONE;
672 break;
673
674 default: /* AT_FAIL or nothing was returned */
675 cmdExtError (EXT_ERR_NotPresent);
676 break;
677 }
678 return (map_aci_2_ati_rslt (ret));
679 }
680 #endif /* no FF_ATI_BAT */
681 }
682
683 GLOBAL T_ATI_RSLT queatPlusCFUN (char *cl, UBYTE srcId)
684 {
685 T_ACI_RETURN ret = AT_FAIL;
686 T_ACI_CFUN_FUN fun = CFUN_FUN_NotPresent;
687
688 #ifdef FF_ATI_BAT
689 {
690 T_BAT_cmd_send cmd;
691 T_BAT_no_parameter dummy;
692
693 TRACE_FUNCTION("queatPlusCFUN() calls bat_send() <=== as APPLICATION");
694
695 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CFUN;
696 dummy.bat_dummy = 0xFF;
697 cmd.params.ptr_que_plus_cfun = &dummy;
698 bat_send(ati_bat_get_client(srcId), &cmd);
699 return ATI_EXCT; /* executing, because response is passed by callback function */
700 }
701 #else /* no FF_ATI_BAT */
702 TRACE_FUNCTION("queatPlusCFUN()");
703
704 ret = qAT_PlusCFUN((T_ACI_CMD_SRC)srcId, &fun);
705 if (ret EQ AT_CMPL)
706 {
707 resp_disp(srcId, cl,"e",&fun);
708 return ATI_CMPL;
709 }
710 else
711 {
712 cmdCmeError(CME_ERR_Unknown);
713 return ATI_FAIL;
714 }
715 #endif /* no FF_ATI_BAT */
716 }
717
718 /*
719 +--------------------------------------------------------------------+
720 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
721 | STATE : code ROUTINE : atPlusCIMI |
722 +--------------------------------------------------------------------+
723
724 PURPOSE : +CIMI command (request international mobile subscriber
725 identity)
726 */
727 GLOBAL T_ATI_RSLT setatPlusCIMI(char *cl, UBYTE srcId)
728 {
729 #ifndef FF_ATI_BAT
730 CHAR imsi[MAX_IMSI_LEN+1]; /* +1 for '\0' */
731 #endif
732
733 T_ACI_RETURN ret = AT_FAIL;
734 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
735
736 TRACE_FUNCTION("setatPlusCIMI()");
737
738 #ifdef FF_ATI_BAT
739
740 {
741 T_BAT_cmd_send cmd;
742 T_BAT_no_parameter dummy;
743
744 TRACE_FUNCTION("setatPlusCIMI() calls bat_send() <=== as APPLICATION");
745
746 cmd.ctrl_params = BAT_CMD_SET_PLUS_CIMI;
747 dummy.bat_dummy = 0xFF;
748 cmd.params.ptr_set_plus_cimi = &dummy;
749
750 bat_send(ati_bat_get_client(srcId), &cmd);
751
752 src_params->curAtCmd=AT_CMD_CIMI;
753 return(ATI_EXCT);
754 }
755
756 #else /* no FF_ATI_BAT */
757
758 ret = qAT_PlusCIMI((T_ACI_CMD_SRC)srcId, imsi);
759 switch (ret)
760 {
761 case( AT_CMPL ):
762
763 sprintf(g_sa,"%s",imsi);
764 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
765 break;
766
767 case( AT_EXCT ):
768 src_params->curAtCmd = AT_CMD_CIMI;
769 break;
770
771 default:
772
773 break;
774 }
775 return (map_aci_2_ati_rslt(ret));
776
777 #endif /* no FF_ATI_BAT */
778 }
779
780
781 /*
782 +--------------------------------------------------------------------+
783 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
784 | STATE : code ROUTINE : atPlusCRSM |
785 +--------------------------------------------------------------------+
786
787 PURPOSE : +CRSM Restricted SIM access
788 */
789 GLOBAL T_ATI_RSLT setatPlusCRSM(char *cl, UBYTE srcId)
790 {
791 T_ACI_RETURN ret = AT_FAIL;
792 UBYTE *data;
793 USHORT lenData = 0;
794 T_ACI_CRSM_CMD cmd = CRSM_CMD_NotPresent;
795 SHORT fileId = ACI_NumParmNotPresent,
796 p1 = ACI_NumParmNotPresent,
797 p2 = ACI_NumParmNotPresent,
798 p3 = ACI_NumParmNotPresent;
799 USHORT lenDataStr = 0;
800 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
801
802
803 TRACE_FUNCTION("setatPlusCRSM");
804
805 cl = parse(cl,"drrrrl", &cmd,&fileId, &p1, &p2, &p3,&lenDataStr,&data );
806 if(!cl)
807 {
808 cmdCmeError(CME_ERR_OpNotAllow);
809 return ATI_FAIL;
810 }
811
812 utl_hexToGsm( data, lenDataStr, data, &lenData, GSM_ALPHA_Def,
813 CSCS_ALPHA_Reserved );
814
815 #ifdef FF_ATI_BAT
816 {
817 T_BAT_cmd_send bat_cmd;
818 T_BAT_cmd_set_plus_crsm crsm;
819
820 /*
821 * If the data is too big for the BAT structure, there's
822 * nothing we can do. A truncated version would be meaningless.
823 */
824 if (lenData>BAT_MAX_CRSM_DATA_LEN)
825 return(ATI_FAIL);
826
827 bat_cmd.ctrl_params = BAT_CMD_SET_PLUS_CRSM;
828 bat_cmd.params.ptr_set_plus_crsm=&crsm;
829
830 /*
831 * This relies on T_ACI_CRSM_COMMAND and T_BAT_plus_crsm_command
832 * being identical. They are, except in that the ACI version has
833 * a 'not present' value. This is not an issue in this direction.
834 */
835 crsm.command=(T_BAT_plus_crsm_command)cmd;
836
837 crsm.fileid=(S32)fileId;
838 crsm.p1=(S16)p1;
839 crsm.p2=(S16)p2;
840 crsm.p3=(S16)p3;
841 crsm.c_data=(U8)lenData;
842 memcpy(crsm.data,data,lenData);
843
844 bat_send(ati_bat_get_client(srcId),&bat_cmd);
845
846 src_params->curAtCmd=AT_CMD_CRSM;
847 return(ATI_EXCT);
848 }
849 #else /* no FF_ATI_BAT */
850
851 ret = sAT_PlusCRSM( (T_ACI_CMD_SRC)srcId, cmd, fileId, p1, p2, p3,
852 lenData, data );
853 if (ret EQ AT_EXCT)
854 {
855 src_params->curAtCmd = AT_CMD_CRSM;
856 }
857 if (ret EQ AT_FAIL)
858 {
859 cmdCmeError(CME_ERR_Unknown);
860 }
861 return (map_aci_2_ati_rslt(ret));
862
863 #endif /* no FF_ATI_BAT */
864 }
865
866 /*
867 +--------------------------------------------------------------------+
868 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
869 | STATE : code ROUTINE : setatPlusCSIM |
870 +--------------------------------------------------------------------+
871
872 PURPOSE : +CSIM Generic SIM access
873 */
874 GLOBAL T_ATI_RSLT setatPlusCSIM(char *cl, UBYTE srcId)
875 {
876 T_ACI_RETURN ret = AT_FAIL;
877 USHORT given_length;
878 UBYTE *data;
879 USHORT lenData = 0;
880 USHORT lenDataStr = 0;
881
882
883 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
884
885
886 TRACE_FUNCTION("setatPlusCSIM");
887
888 cl = parse(cl,"rl", &given_length, &lenDataStr, &data );
889 if(!cl)
890 {
891 cmdCmeError(CME_ERR_OpNotAllow);
892 return ATI_FAIL;
893 }
894
895 if ((given_length > MAX_SIM_TRANSP*2)
896 OR (given_length NEQ lenDataStr)
897 OR (lenDataStr EQ 0))
898 {
899 cmdCmeError(CME_ERR_OpNotAllow);
900 return ATI_FAIL;
901 }
902
903 lenData = utl_HexStrToBin(data, lenDataStr, data, MAX_SIM_TRANSP);
904
905 if (lenData EQ 0)
906 {
907 TRACE_EVENT("invalid character in <command>");
908 cmdCmeError(CME_ERR_OpNotAllow);
909 return ATI_FAIL;
910 }
911
912 #ifdef FF_ATI_BAT
913
914 {
915 T_BAT_cmd_send bat_cmd;
916 T_BAT_cmd_set_plus_csim csim;
917
918 /*
919 * If the data is too big for the BAT structure, there's
920 * nothing we can do. A truncated version would be meaningless.
921 */
922 if (lenData>BAT_MAX_CSIM_CMD_LEN)
923 return(ATI_FAIL);
924
925 bat_cmd.ctrl_params = BAT_CMD_SET_PLUS_CSIM;
926 bat_cmd.params.ptr_set_plus_csim=&csim;
927
928 csim.c_command=(U8)lenData;
929 memcpy(csim.command,data,lenData);
930
931 bat_send(ati_bat_get_client(srcId),&bat_cmd);
932
933 src_params->curAtCmd=AT_CMD_CRSM;
934 return(ATI_EXCT);
935 }
936
937 #else /* no FF_ATI_BAT */
938
939 ret = sAT_PlusCSIM( (T_ACI_CMD_SRC)srcId, lenData, data );
940 if (ret EQ AT_EXCT)
941 {
942 src_params->curAtCmd = AT_CMD_CSIM;
943 }
944 if (ret EQ AT_FAIL)
945 {
946 cmdCmeError(CME_ERR_Unknown);
947 }
948 return (map_aci_2_ati_rslt(ret));
949
950 #endif /* no FF_ATI_BAT */
951 }
952
953 #ifdef TI_PS_FF_AT_P_CMD_ATR
954 /*
955 +--------------------------------------------------------------------+
956 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
957 | STATE : code ROUTINE : queatPercentATR |
958 +--------------------------------------------------------------------+
959
960 PURPOSE : %ATR answer to reset (query)
961 */
962 GLOBAL T_ATI_RSLT queatPercentATR ( char *cl, UBYTE srcId )
963 {
964 #ifndef FF_ATI_BAT
965 T_ACI_RETURN ret;
966 UBYTE i;
967 UBYTE phase;
968 UBYTE atr_len = 0;
969 UBYTE atr_info[MAX_SIM_ATR];
970 #endif
971
972 TRACE_FUNCTION( "queatPercentATR()" );
973
974 #ifdef FF_ATI_BAT
975 {
976 T_BAT_cmd_send cmd;
977 T_BAT_no_parameter dummy;
978
979 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_ATR;
980 dummy.bat_dummy = 0xFF;
981 cmd.params.ptr_que_percent_atr = &dummy;
982
983 /*
984 * Without this we will lose track of the source ID by the time the
985 * response arrives.
986 */
987 srcId_cb=srcId;
988
989 bat_send(ati_bat_get_client(srcId), &cmd);
990 return(ATI_EXCT);
991 }
992 #else /* no FF_ATI_BAT */
993
994 ret = qAT_PercentATR( (T_ACI_CMD_SRC)srcId, &phase, &atr_len, atr_info );
995
996 if( ret NEQ AT_CMPL )
997 {
998 cmdCmeError(CME_ERR_Unknown);
999 }
1000 else
1001 {
1002 if(phase NEQ NOT_PRESENT_8BIT)
1003 {
1004 i=sprintf(g_sa,"%s%d,", "%ATR: ", phase);/* if phase available.. return phase*/
1005 }
1006 else
1007 {
1008 i=sprintf(g_sa,"%s", "%ATR: FFFF");/* else return FFFF*/
1009 }
1010
1011 if(atr_len) /* if ATR data available... return ATR data*/
1012 {
1013 sprintf(g_sa+i,",");
1014 utl_binToHex( atr_info, atr_len, g_sa+i );
1015 }
1016
1017 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
1018 }
1019 return (map_aci_2_ati_rslt(ret));
1020
1021 #endif /* no FF_ATI_BAT */
1022 }
1023 #endif /* TI_PS_FF_AT_P_CMD_ATR */
1024
1025 /*
1026 +--------------------------------------------------------------------+
1027 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1028 | STATE : code ROUTINE : setatPercentCPRI |
1029 +--------------------------------------------------------------------+
1030
1031 PURPOSE : %CPRI command (select cipher indication mode)
1032 */
1033
1034 GLOBAL T_ATI_RSLT setatPercentCPRI ( char *cl, UBYTE srcId )
1035 {
1036 T_ACI_RETURN ACI_return = AT_FAIL;
1037 UBYTE CPRImode;
1038
1039 TRACE_FUNCTION( "setatPercentCPRI()" );
1040
1041 switch( *cl )
1042 {
1043 case '0':
1044 case '1':
1045 CPRImode = *cl - 0x30; /* make binary value */
1046 cl++;
1047 ACI_return = sAT_PercentCPRI( (T_ACI_CMD_SRC)srcId, CPRImode );
1048 if( ACI_return NEQ AT_CMPL )
1049 {
1050 cmdCmeError(CME_ERR_Unknown);
1051 }
1052 else /* If ACI_return is AT_CMPL,updates the CPRI_stat with CPRImode */
1053 {
1054 ati_user_output_cfg[srcId].CPRI_stat = CPRImode;
1055 }
1056 break;
1057 default:
1058 cmdCmeError(CME_ERR_OpNotAllow);
1059 break;
1060 }
1061 return (map_aci_2_ati_rslt(ACI_return));
1062 }
1063
1064
1065 GLOBAL T_ATI_RSLT queatPercentCPRI ( char *cl, UBYTE srcId )
1066 {
1067 T_ACI_RETURN ACI_return = AT_FAIL;
1068 UBYTE CPRIenabled;
1069
1070 TRACE_FUNCTION( "queatPercentCPRI()" );
1071
1072 ACI_return = qAT_PercentCPRI( (T_ACI_CMD_SRC)srcId, &CPRIenabled );
1073
1074 if( ACI_return NEQ AT_CMPL )
1075 {
1076 cmdCmeError(CME_ERR_Unknown);
1077 }
1078 else
1079 {
1080 if (CPRIenabled)
1081 {
1082 CPRIenabled = ati_user_output_cfg[srcId].CPRI_stat;
1083 }
1084 else
1085 {
1086 CPRIenabled = CI_DISABLED;
1087 }
1088 resp_disp(srcId, cl,"b",&CPRIenabled);
1089 }
1090 return (map_aci_2_ati_rslt(ACI_return));
1091 }
1092
1093 /*
1094 +--------------------------------------------------------------------+
1095 | PROJECT : GSM-F&D (8411) MODULE : |
1096 | STATE : code ROUTINE : setatPercentPVRF |
1097 +--------------------------------------------------------------------+
1098
1099 PURPOSE : return information relating to status of PIN.
1100
1101 */
1102
1103 GLOBAL T_ATI_RSLT setatPercentPVRF( char *cl, UBYTE srcId )
1104 {
1105 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1106 T_ACI_PVRF_TYPE type;
1107 CHAR pin[10];
1108 CHAR newpin[10];
1109 T_ACI_RETURN ret = AT_FAIL;
1110
1111 TRACE_FUNCTION( "setatPercentPVRF()" );
1112
1113 /* parse mode */
1114 cl = parse (cl, "dss", &type, (LONG) sizeof (pin),pin, (LONG) sizeof (newpin), newpin);
1115 if (!cl OR (type > PVRF_TYPE_Puk2) OR (type <= PVRF_TYPE_NotPresent))/*lint !e685 (Warning -- :685 Relational operator '>' always evaluates to 'false ) */
1116 {
1117 cmdCmeError (CME_ERR_OpNotAllow);
1118 return (ATI_FAIL);
1119 }
1120
1121 #ifdef FF_ATI_BAT
1122
1123 {
1124 T_BAT_cmd_send cmd;
1125 T_BAT_cmd_set_percent_pvrf pvrf;
1126 UBYTE len;
1127
1128 cmd.ctrl_params = BAT_CMD_SET_PERCENT_PVRF;
1129 cmd.params.ptr_set_percent_pvrf=&pvrf;
1130
1131 /*
1132 * This relies on T_ACI_PVRF_TYPE and T_BAT_percent_pvrf_type
1133 * being identical. They are, except in that the ACI version has
1134 * a 'not present' value. In this direction, that doesn't matter.
1135 */
1136 pvrf.type=(T_BAT_percent_pvrf_type)type;
1137
1138 len=strlen(pin);
1139 if (len>BAT_MAX_PVRF_PIN_LEN)
1140 return(ATI_FAIL);
1141
1142 pvrf.c_pin=(U8)len;
1143 memcpy(pvrf.pin,pin,len);
1144
1145 len=strlen(newpin);
1146 if (len>BAT_MAX_PVRF_NEW_PIN_LEN)
1147 return(ATI_FAIL);
1148
1149 if (len)
1150 {
1151 pvrf.v_newpin=TRUE;
1152 pvrf.c_newpin=(U8)len;
1153 memcpy(pvrf.newpin,newpin,len);
1154 }
1155 else
1156 {
1157 pvrf.v_newpin=FALSE;
1158 }
1159 bat_send(ati_bat_get_client(srcId), &cmd);
1160
1161 src_params->curAtCmd=AT_CMD_PVRF;
1162 return(ATI_EXCT);
1163 }
1164
1165 #else /* no FF_ATI_BAT */
1166
1167 ret = sAT_PercentPVRF ((T_ACI_CMD_SRC)srcId, type, pin, newpin);
1168
1169 switch (ret)
1170 {
1171 case (AT_CMPL): /*operation completed*/
1172 break;
1173 case (AT_EXCT):
1174 src_params->curAtCmd = AT_CMD_PVRF;
1175 break;
1176 default:
1177 cmdCmeError(CME_ERR_Unknown); /*Command failed*/
1178 break;
1179 }
1180 return (map_aci_2_ati_rslt(ret));
1181
1182 #endif /* no FF_ATI_BAT */
1183 }
1184
1185 /*
1186 +--------------------------------------------------------------------+
1187 | PROJECT : GPRS (8441) MODULE : GACI_CMD |
1188 | STATE : code ROUTINE : queatPercentPVRF |
1189 +--------------------------------------------------------------------+
1190
1191 PURPOSE : %PVRF command
1192 */
1193 GLOBAL T_ATI_RSLT queatPercentPVRF (char *cl, UBYTE srcId)
1194 {
1195 TRACE_FUNCTION("queatPercentPVRF()");
1196
1197 #ifdef FF_ATI_BAT
1198 {
1199 T_BAT_cmd_send cmd;
1200 T_BAT_no_parameter dummy;
1201
1202 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_PVRF;
1203 dummy.bat_dummy = 0xFF;
1204 cmd.params.ptr_que_percent_pvrf = &dummy;
1205 bat_send(ati_bat_get_client(srcId), &cmd);
1206 return(ATI_EXCT);
1207 }
1208 #else /* no FF_ATI_BAT */
1209 {
1210 T_ACI_PVRF_STAT ps1;
1211 T_ACI_PVRF_STAT ps2;
1212 CHAR *me = "%PVRF: ";
1213 SHORT pn1cnt = 0;
1214 SHORT pn2cnt = 0;
1215 SHORT pk1cnt = 0;
1216 SHORT pk2cnt = 0;
1217
1218 T_ACI_RETURN ret = qAT_PercentPVRF((T_ACI_CMD_SRC)srcId, &pn1cnt, &pn2cnt, &pk1cnt, &pk2cnt, &ps1, &ps2);
1219
1220 if (ret NEQ AT_CMPL)
1221 {
1222 cmdCmeError(CME_ERR_Unknown);
1223 return (ATI_FAIL);
1224 }
1225
1226 sprintf(g_sa,"%s%d, %d, %d, %d, %d, %d", me, pn1cnt, pn2cnt, pk1cnt, pk2cnt, ps1, ps2);
1227 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
1228
1229 return (ATI_CMPL);
1230 }
1231 #endif /* no FF_ATI_BAT */
1232 }
1233
1234 #ifdef TI_PS_FF_AT_P_CMD_CUST
1235 /*
1236 +--------------------------------------------------------------------+
1237 | PROJECT : GSM-F&D (8411) MODULE : |
1238 | STATE : code ROUTINE : setatPercentCUST |
1239 +--------------------------------------------------------------------+
1240
1241 PURPOSE : %CUST command ( Set Customisation Mode Function )
1242 */
1243
1244 GLOBAL T_ATI_RSLT setatPercentCUST ( char *cl, UBYTE srcId ) /* Function protype is T_ATI_RSLT not T_ACI_RETURN so it is changed */
1245 {
1246 TRACE_FUNCTION( "setatPercentCUST()" );
1247
1248 #ifdef FF_ATI_BAT
1249
1250 {
1251 T_BAT_cmd_send cmd;
1252 T_BAT_cmd_set_percent_cust cust;
1253
1254 cmd.ctrl_params = BAT_CMD_SET_PERCENT_CUST;
1255 cmd.params.ptr_set_percent_cust=&cust;
1256
1257 switch (*cl)
1258 {
1259 case '0':
1260 cust.mode=BAT_P_CUST_MODE_NORMAL;
1261 break;
1262
1263 case '1':
1264 cust.mode=BAT_P_CUST_MODE_BEHAVIOUR_1;
1265 break;
1266
1267 default:
1268 cmdCmeError(CME_ERR_OpNotAllow);
1269 return(ATI_FAIL);
1270 }
1271 bat_send(ati_bat_get_client(srcId), &cmd);
1272
1273 return(ATI_EXCT);
1274 }
1275 #else /* no FF_ATI_BAT */
1276
1277 switch( *cl )
1278 {
1279 case '0':
1280 if (sAT_PercentCUST((T_ACI_CMD_SRC)srcId, CUST_NORMAL_BEHAVIOUR) EQ AT_FAIL)
1281 {
1282 cmdCmeError(CME_ERR_Unknown);
1283 return (ATI_FAIL);
1284 }
1285 break;
1286
1287 case '1':
1288 if (sAT_PercentCUST ((T_ACI_CMD_SRC)srcId, CUST_MODE_BEHAVIOUR_1) EQ AT_FAIL)
1289 {
1290 cmdCmeError(CME_ERR_Unknown);
1291 return (ATI_FAIL);
1292 }
1293 break;
1294
1295 default:
1296 cmdCmeError(CME_ERR_OpNotAllow);
1297 return (ATI_FAIL);
1298 }
1299
1300 return (ATI_CMPL);
1301
1302 #endif /* no FF_ATI_BAT */
1303 }
1304
1305 /*
1306 +--------------------------------------------------------------------+
1307 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1308 | STATE : code ROUTINE : queatPercentCUST |
1309 +--------------------------------------------------------------------+
1310
1311 PURPOSE : %CUST command (Customisaton Mode)
1312 */
1313 GLOBAL T_ATI_RSLT queatPercentCUST (char *cl, UBYTE srcId)
1314 {
1315 TRACE_FUNCTION("queatPercentCUST()");
1316
1317 #ifdef FF_ATI_BAT
1318 {
1319 T_BAT_cmd_send cmd;
1320 T_BAT_no_parameter dummy;
1321
1322 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_CUST;
1323 dummy.bat_dummy = 0xFF;
1324 cmd.params.ptr_que_percent_cust = &dummy;
1325 bat_send(ati_bat_get_client(srcId), &cmd);
1326 return(ATI_EXCT);
1327 }
1328 #else /* no FF_ATI_BAT */
1329 {
1330 T_CUST_MOD mode;
1331 T_ACI_RETURN ret = qAT_PercentCUST((T_ACI_CMD_SRC)srcId, &mode);
1332
1333 if (ret NEQ AT_CMPL)
1334 {
1335 cmdCmeError(CME_ERR_Unknown);
1336 return (ATI_FAIL);
1337 }
1338
1339 sprintf(g_sa,"%%CUST: %d", mode);
1340 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
1341
1342 return ATI_CMPL;
1343 }
1344 #endif /* no FF_ATI_BAT */
1345 }
1346 #endif /* TI_PS_FF_AT_P_CMD_CUST */
1347 /*
1348 +--------------------------------------------------------------------+
1349 | PROJECT : GSM-F&D (8411) MODULE : |
1350 | STATE : code ROUTINE : setatPercentSATCC |
1351 +--------------------------------------------------------------------+
1352
1353 PURPOSE : %SATCC command ( Enable/Disable the Call/Short Message Control By SIM )
1354 */
1355
1356 GLOBAL T_ATI_RSLT setatPercentSATCC ( char *cl, UBYTE srcId ) /* Function protype is T_ATI_RSLT not T_ACI_RETURN so it is changed */
1357
1358 {
1359 #ifdef FF_ATI_BAT
1360 T_BAT_cmd_send bat_cmd;
1361 T_BAT_cmd_set_percent_satcc satcc;
1362 #endif
1363 TRACE_FUNCTION( "setatPercentSATCC()" );
1364
1365 #ifdef FF_ATI_BAT
1366 switch( *cl )
1367 {
1368 case '0':
1369 satcc.mode = BAT_P_SATCC_MODE_INACTIVE;
1370 break;
1371 case '1':
1372 satcc.mode = BAT_P_SATCC_MODE_ACTIVE;
1373 break;
1374 default:
1375 cmdCmeError(CME_ERR_Unknown);
1376 return (ATI_FAIL);
1377 }
1378
1379 bat_cmd.ctrl_params = BAT_CMD_SET_PERCENT_SATCC;
1380 bat_cmd.params.ptr_set_percent_satcc = &satcc;
1381
1382 bat_send(ati_bat_get_client(srcId),&bat_cmd);
1383
1384 return(ATI_EXCT);
1385
1386 #else
1387 switch( *cl )
1388 {
1389 case '0':
1390 if (sAT_PercentSATCC((T_ACI_CMD_SRC)srcId, SATCC_CONTROL_BY_SIM_INACTIVE) EQ AT_FAIL)
1391 {
1392 cmdCmeError(CME_ERR_Unknown);
1393 return (ATI_FAIL);
1394 }
1395 break;
1396
1397 case '1':
1398 if (sAT_PercentSATCC ((T_ACI_CMD_SRC)srcId, SATCC_CONTROL_BY_SIM_ACTIVE) EQ AT_FAIL)
1399 {
1400 cmdCmeError(CME_ERR_Unknown);
1401 return (ATI_FAIL);
1402 }
1403 break;
1404
1405 default:
1406 cmdCmeError(CME_ERR_OpNotAllow);
1407 return (ATI_FAIL);
1408 }
1409
1410 return (ATI_CMPL);
1411
1412 #endif
1413 }
1414
1415 /*
1416 +--------------------------------------------------------------------+
1417 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1418 | STATE : code ROUTINE : queatPercentSATCC |
1419 +--------------------------------------------------------------------+
1420
1421 PURPOSE : %SATCC command (Query Call/Short Message control By SIM)
1422 */
1423 GLOBAL T_ATI_RSLT queatPercentSATCC (char *cl, UBYTE srcId)
1424 {
1425 #ifdef FF_ATI_BAT
1426 T_BAT_cmd_send bat_cmd;
1427 T_BAT_no_parameter satcc;
1428 #else
1429 T_SAT_CC_MOD mode;
1430 T_ACI_RETURN ret = AT_FAIL;
1431 #endif
1432
1433 TRACE_FUNCTION("queatPercentSATCC()");
1434
1435 #ifdef FF_ATI_BAT
1436 bat_cmd.ctrl_params = BAT_CMD_QUE_PERCENT_SATCC;
1437 bat_cmd.params.ptr_que_percent_satcc = &satcc;
1438
1439 bat_send(ati_bat_get_client(srcId),&bat_cmd);
1440
1441 return(ATI_EXCT);
1442
1443 #else
1444
1445 ret = qAT_PercentSATCC((T_ACI_CMD_SRC)srcId, &mode);
1446
1447 if (ret NEQ AT_CMPL)
1448 {
1449 cmdCmeError(CME_ERR_Unknown);
1450 return (ATI_FAIL);
1451 }
1452
1453 sprintf(g_sa,"%%SATCC: %d", mode);
1454 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
1455
1456 #endif /*FF_ATI_BAT*/
1457
1458 return ATI_CMPL;
1459 }
1460
1461 /*
1462 +--------------------------------------------------------------------+
1463 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1464 | STATE : code ROUTINE : setatPercentSIMIND |
1465 +--------------------------------------------------------------------+
1466
1467 PURPOSE : enable %SIMINS / %SIMREM indications
1468 */
1469
1470 GLOBAL T_ATI_RSLT setatPercentSIMIND(char *cl, UBYTE srcId)
1471 {
1472 int mode = 1;
1473
1474 TRACE_FUNCTION("setatPercentSIMIND()");
1475
1476 /* parse mode */
1477 cl = parse (cl, "d", &mode);
1478
1479 if (mode EQ 0 OR mode EQ 1)
1480 {
1481 ati_user_output_cfg[srcId].SIMIND_stat = mode;
1482 return (ATI_CMPL);
1483 }
1484 else
1485 {
1486 cmdCmeError(CME_ERR_OpNotAllow);
1487 return (ATI_FAIL);
1488 }
1489 }
1490
1491 /*
1492 +--------------------------------------------------------------------+
1493 | PROJECT : GPRS (8441) MODULE : ACI_CMD |
1494 | STATE : code ROUTINE : queatPercentSIMIND |
1495 +--------------------------------------------------------------------+
1496
1497 PURPOSE : query status of %SIMINS / %SIMREM indications
1498 */
1499 GLOBAL T_ATI_RSLT queatPercentSIMIND(char *cl, UBYTE srcId)
1500 {
1501 CHAR *me = "%SIMIND";
1502
1503 TRACE_FUNCTION("queatPercentSIMIND()");
1504
1505 sprintf(g_sa,"%s: %d", me, ati_user_output_cfg[srcId].SIMIND_stat);
1506 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
1507
1508 return (ATI_CMPL);
1509 }
1510
1511 #ifdef FF_DUAL_SIM
1512 /*
1513 +--------------------------------------------------------------------+
1514 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1515 | STATE : code ROUTINE : atPlusCFUN |
1516 +--------------------------------------------------------------------+
1517
1518 PURPOSE : %SIM command (SIM Selection)
1519 */
1520
1521 GLOBAL T_ATI_RSLT setatPercentSIM (char *cl, UBYTE srcId)
1522 {
1523 T_ACI_RETURN ret = AT_FAIL;
1524 UBYTE sim_num;
1525
1526 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1527
1528 TRACE_FUNCTION("setatPercentSIM()");
1529
1530 /*input functionality*/
1531 cl = parse (cl,"d",&sim_num);
1532 if ( !cl )
1533 {
1534 cmdCmeError (CME_ERR_OpNotAllow);
1535 return(ATI_FAIL);
1536 }
1537
1538 ret = sAT_PercentSIM (srcId,sim_num);
1539 switch (ret)
1540 {
1541 case AT_EXCT: /*Command is executing*/
1542 src_params->curAtCmd = AT_CMD_SIM;
1543 break;
1544
1545 case AT_FAIL:
1546 src_params->curAtCmd = AT_CMD_NONE;
1547 break;
1548
1549 default:
1550 cmdCmeError(CME_ERR_Unknown);
1551 break;
1552 }
1553 return (map_aci_2_ati_rslt (ret));
1554 }
1555
1556 GLOBAL T_ATI_RSLT queatPercentSIM (char *cl, UBYTE srcId)
1557 {
1558 T_ACI_RETURN ret = AT_FAIL;
1559 UBYTE sim_num;
1560
1561 TRACE_FUNCTION("queatPercentSIM()");
1562
1563 ret = qAT_PercentSIM(srcId, &sim_num);
1564
1565 if (ret EQ AT_CMPL)
1566 {
1567 resp_disp(srcId, cl,"b",&sim_num);
1568 return ATI_CMPL;
1569 }
1570 else
1571 {
1572 cmdCmeError(CME_ERR_Unknown);
1573 return ATI_FAIL;
1574 }
1575 }
1576 #endif /*FF_DUAL_SIM*/
1577
1578 #ifdef FF_CPHS_REL4
1579 /*
1580 +--------------------------------------------------------------------+
1581 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1582 | STATE : code ROUTINE : setatPercentCFIS |
1583 +--------------------------------------------------------------------+
1584
1585 PURPOSE : %CFIS command (Call Forwarding Unconditional)
1586 */
1587
1588 GLOBAL T_ATI_RSLT setatPercentCFIS (char *cl, UBYTE srcId)
1589 {
1590 T_ACI_RETURN ret = AT_FAIL;
1591 T_ACI_CFIS_MOD cfisMode = CFIS_MOD_NotPresent;
1592 UBYTE index = NOT_PRESENT_8BIT;
1593 UBYTE mspId;
1594 UBYTE cfuStat;
1595 CHAR number[MAX_PHB_NUM_LEN];
1596 T_ACI_TOA type;
1597 T_ACI_TOA *p_type;
1598 SHORT toa_oct = 0;
1599 UBYTE cc2_Id = NOT_PRESENT_8BIT;
1600 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1601
1602 TRACE_FUNCTION( "setatPercentCFIS()" );
1603
1604 /* init */
1605 memset( number, 0, sizeof(number));
1606
1607 cl = parse (cl, "ddddsdd", &cfisMode, &index, &mspId, &cfuStat,
1608 (LONG)MAX_PHB_NUM_LEN, number, &toa_oct , &cc2_Id);
1609
1610 if(!cl)
1611 {
1612 cmdCmeError(CME_ERR_OpNotAllow);
1613 return (ATI_FAIL);
1614 }
1615
1616 if (toa_oct EQ 0)
1617 {
1618 p_type = NULL;
1619 }
1620 else
1621 {
1622 type=toa_demerge(toa_oct);
1623 p_type = &type;
1624 }
1625
1626 if( cfisMode EQ CFIS_MOD_Read)
1627 {
1628 ret=qAT_PercentCFIS(srcId, index );
1629 }
1630 else
1631 {
1632 ret = sAT_PercentCFIS(srcId, cfisMode,index,mspId, cfuStat,
1633 number, p_type, cc2_Id);
1634 }
1635
1636 switch (ret)
1637 {
1638 case AT_EXCT: /*Command is executing*/
1639 src_params->curAtCmd = AT_CMD_P_CFIS;
1640 break;
1641
1642 default:
1643 src_params->curAtCmd = AT_CMD_NONE;
1644 cmdCmeError(CME_ERR_Unknown);
1645 break;
1646 }
1647 return (map_aci_2_ati_rslt (ret));
1648 }
1649
1650 /*
1651 +--------------------------------------------------------------------+
1652 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1653 | STATE : code ROUTINE : setatPercentMWIS |
1654 +--------------------------------------------------------------------+
1655
1656 PURPOSE : %MWIS command (Message Waiting Indication Status)
1657 */
1658
1659 GLOBAL T_ATI_RSLT setatPercentMWIS (char *cl, UBYTE srcId)
1660 {
1661 T_ACI_RETURN ret = AT_FAIL;
1662 T_ACI_MWIS_MOD mwisMode = MWIS_MOD_Invalid;
1663 UBYTE mspId = NOT_PRESENT_8BIT;
1664 T_ACI_MWIS_MWI mwis;
1665 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1666
1667 TRACE_FUNCTION( "setatPercentMWIS()" );
1668
1669 memset(&mwis, 0, sizeof(T_ACI_MWIS_MWI));
1670 cl = parse (cl, "ddddddd", &mwisMode, &mspId, &mwis.mwiStat,
1671 &mwis.mwis_count_voice, &mwis.mwis_count_fax,
1672 &mwis.mwis_count_email,&mwis.mwis_count_other);
1673
1674 if(!cl)
1675 {
1676 cmdCmeError(CME_ERR_OpNotAllow);
1677 return (ATI_FAIL);
1678 }
1679
1680 if( mwisMode EQ MWIS_MOD_Read)
1681 {
1682 ret = qAT_PercentMWIS(srcId, mspId );
1683 }
1684 else
1685 {
1686 ret = sAT_PercentMWIS(srcId, mwisMode,mspId, &mwis);
1687 }
1688
1689 switch (ret)
1690 {
1691 case AT_EXCT: /*Command is executing*/
1692 src_params->curAtCmd = AT_CMD_P_MWIS;
1693 break;
1694
1695 default:
1696 src_params->curAtCmd = AT_CMD_NONE;
1697 cmdCmeError(CME_ERR_Unknown);
1698 break;
1699 }
1700 return (map_aci_2_ati_rslt (ret));
1701 }
1702
1703 /*
1704 +--------------------------------------------------------------------+
1705 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1706 | STATE : code ROUTINE : setatPercentMWI |
1707 +--------------------------------------------------------------------+
1708
1709 PURPOSE : %MWI command (Message Waiting Indication)
1710 */
1711
1712 GLOBAL T_ATI_RSLT setatPercentMWI(char *cl, UBYTE srcId)
1713 {
1714 SHORT mode = ACI_NumParmNotPresent;
1715
1716 TRACE_FUNCTION("setatPercentMWI()");
1717
1718 cl = parse(cl,"r",&mode);
1719 if(!cl OR mode > 1 OR mode < 0)
1720 {
1721 cmdCmeError(CME_ERR_OpNotAllow);
1722 return (ATI_FAIL);
1723 }
1724
1725 ati_user_output_cfg[srcId].MWI_stat=(UBYTE)mode;
1726 return (ATI_CMPL);
1727 }
1728
1729 /*
1730 +--------------------------------------------------------------------+
1731 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1732 | STATE : code ROUTINE : queatPercentMWI |
1733 +--------------------------------------------------------------------+
1734
1735 PURPOSE : %MWI command (Message Waiting Indication)
1736 */
1737
1738 GLOBAL T_ATI_RSLT queatPercentMWI(char *cl, UBYTE srcId)
1739 {
1740 UBYTE mode;
1741
1742 TRACE_FUNCTION("queatPercentMWI()");
1743
1744 mode = ati_user_output_cfg[srcId].MWI_stat;
1745 resp_disp(srcId, cl,"b",&mode);
1746 return (ATI_CMPL);
1747 }
1748
1749
1750 /*
1751 +--------------------------------------------------------------------+
1752 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1753 | STATE : code ROUTINE : setatPercentMBI |
1754 +--------------------------------------------------------------------+
1755
1756 PURPOSE : %MBI command (Mailbox Identifier)
1757 */
1758
1759 GLOBAL T_ATI_RSLT setatPercentMBI (char *cl, UBYTE srcId)
1760 {
1761 T_ACI_RETURN ret = AT_FAIL;
1762 T_ACI_MBN_MODE mbiMode = MBN_Mode_Invalid;
1763 UBYTE index = NOT_PRESENT_8BIT;
1764
1765 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1766
1767 TRACE_FUNCTION( "setatPercentMBI()" );
1768
1769 cl = parse (cl, "dd", &mbiMode, &index);
1770
1771 if(!cl OR (mbiMode NEQ MBN_Mode_Read))
1772 {
1773 cmdCmeError(CME_ERR_OpNotAllow);
1774 return (ATI_FAIL);
1775 }
1776
1777 ret = qAT_PercentMBI(srcId, index );
1778
1779 switch (ret)
1780 {
1781 case AT_EXCT: /*Command is executing*/
1782 src_params->curAtCmd = AT_CMD_P_MBI;
1783 break;
1784
1785 default:
1786 src_params->curAtCmd = AT_CMD_NONE;
1787 cmdCmeError(CME_ERR_Unknown);
1788 break;
1789 }
1790 return (map_aci_2_ati_rslt (ret));
1791 }
1792 /*
1793 +--------------------------------------------------------------------+
1794 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1795 | STATE : code ROUTINE : setatPercentMBDN |
1796 +--------------------------------------------------------------------+
1797
1798 PURPOSE : %MBDN command (Mailbox Dialling Number)
1799 */
1800
1801 GLOBAL T_ATI_RSLT setatPercentMBDN (char *cl, UBYTE srcId)
1802 {
1803 T_ACI_RETURN ret = AT_FAIL;
1804 T_ACI_MBN_MODE mbdnMode = MBN_Mode_Invalid;
1805 UBYTE index = 0;
1806 CHAR number[MAX_MB_NUM_LEN];
1807 CHAR alpha_id[MAX_ALPHA_LEN] = {0x00};
1808 USHORT len_alpha_id = 0;
1809 USHORT lenCvtd = 0; /* holds length of converted text */
1810 T_ACI_PB_TEXT *p_text = NULL; /* holds pointer to converted text */
1811 T_ACI_PB_TEXT cvtdText; /* holds text converted to SIM alpha */
1812 T_ACI_TOA type;
1813 T_ACI_TOA *p_type;
1814 CHAR *p_number;
1815 SHORT toa_oct = 0;
1816 UBYTE cc2_Id = NOT_PRESENT_8BIT;
1817 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1818
1819 TRACE_FUNCTION( "setatPercentMBDN()" );
1820
1821 /* init */
1822 memset( number, 0, sizeof(number));
1823
1824 cl = parse (cl, "ddsddz", &mbdnMode, &index,(LONG)MAX_MB_NUM_LEN, number,
1825 &toa_oct , &cc2_Id, (LONG)MAX_ALPHA_LEN,
1826 strlen(cl), cl, &len_alpha_id, alpha_id);
1827
1828 if(!cl OR (mbdnMode < 0 OR mbdnMode > 2) OR (!index))
1829 {
1830 cmdCmeError(CME_ERR_OpNotAllow);
1831 return (ATI_FAIL);
1832 }
1833
1834 /* translate alpha text to SIM */
1835 if ( len_alpha_id NEQ 0 )
1836 {
1837 utl_chsetToSim ((UBYTE*)alpha_id, len_alpha_id, (UBYTE*)cvtdText.data,
1838 &lenCvtd, GSM_ALPHA_Def);
1839 }
1840
1841 if (toa_oct EQ 0)
1842 {
1843 p_type = NULL;
1844 }
1845 else
1846 {
1847 type=toa_demerge(toa_oct);
1848 p_type = &type;
1849 }
1850
1851 /* when the text is empty p_text to NULL */
1852 if (lenCvtd EQ 0 )
1853 {
1854 p_text = NULL;
1855 }
1856 else
1857 {
1858 p_text = &cvtdText;
1859 cvtdText.len = (UBYTE)lenCvtd;
1860 }
1861
1862 /* set pointer for number */
1863 if (number[0] EQ '\0') /* The number given is empty */
1864 {
1865 p_number = NULL;
1866 }
1867 else
1868 {
1869 p_number = number;
1870 }
1871
1872 if( mbdnMode EQ MBN_Mode_Read)
1873 {
1874 ret = qAT_PercentMBDN(srcId, index );
1875 }
1876 else
1877 {
1878 ret = sAT_PercentMBDN(srcId, mbdnMode,index,
1879 p_number, p_type, cc2_Id, p_text);
1880 }
1881
1882 switch (ret)
1883 {
1884 case AT_EXCT: /*Command is executing*/
1885 src_params->curAtCmd = AT_CMD_P_MBDN;
1886 break;
1887
1888 default:
1889 src_params->curAtCmd = AT_CMD_NONE;
1890 cmdCmeError(CME_ERR_Unknown);
1891 break;
1892 }
1893 return (map_aci_2_ati_rslt (ret));
1894 }
1895 #endif /* FF_CPHS_REL4 */
1896
1897 #endif /* ATI_SIM_C */