FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/ati_sat.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 for SAT related commands
18 +-----------------------------------------------------------------------------
19 */
20
21 #include "config.h"
22 #include "fixedconf.h"
23 #include "condat-features.h"
24 #include "aci_conf.h"
25
26 #ifdef SIM_TOOLKIT
27
28 #ifndef ATI_SAT_C
29 #define ATI_SAT_C
30
31 #include "aci_all.h"
32 /*==== INCLUDES ===================================================*/
33 #include "aci_cmh.h"
34 #include "ati_cmd.h"
35 #include "aci_cmd.h"
36 #include "aci_lst.h"
37
38 #include "aci_io.h"
39 #include "aci_prs.h"
40
41 #include "ati_int.h"
42
43 #ifdef FF_ATI_BAT
44
45 #include "typedefs.h"
46 #include "gdd.h"
47 #include "bat.h"
48
49 #include "ati_bat.h"
50 #endif /* FF_ATI_BAT */
51
52 /*==== CONSTANTS ==================================================*/
53
54 /*==== TYPES ======================================================*/
55
56 /*==== EXPORT =====================================================*/
57
58 /*==== VARIABLES ==================================================*/
59 GLOBAL UBYTE sat[CMD_SRC_MAX];
60
61 EXTERN UBYTE run_at_id;
62
63 /*==== FUNCTIONS ==================================================*/
64
65 /*
66 +--------------------------------------------------------------------+
67 | PROJECT : GSM-F&D (8411) MODULE : ACI_SAT_CMD |
68 | STATE : code ROUTINE : atPercentSATC |
69 +--------------------------------------------------------------------+
70
71 PURPOSE : %SATC Configuration for SIM application toolkit.
72 */
73
74 GLOBAL void aci_sat_cmd_init (void)
75 {
76 T_ACI_CMD_SRC i;
77 for (i=CMD_SRC_LCL; i<CMD_SRC_MAX; i++)
78 sat[i] = 0; /* no SIM Toolkit indications */
79 }
80
81 /*
82 +--------------------------------------------------------------------+
83 | PROJECT : GSM-F&D (8411) MODULE : ACI_SAT_CMD |
84 | STATE : code ROUTINE : atPercentSATC |
85 +--------------------------------------------------------------------+
86
87 PURPOSE : %SATC Configuration for SIM application toolkit.
88 */
89
90 GLOBAL T_ATI_RSLT setatPercentSATC(char *cl, UBYTE srcId)
91 {
92 T_ACI_RETURN ret = AT_FAIL;
93 USHORT lenPrfl = 0;
94 USHORT lenPrflStr = 0;
95 SHORT stat = -1;
96 UBYTE *satPrflStr = NULL;
97
98 cl=parse(cl,"rl", &stat,&lenPrflStr,&satPrflStr );
99 #ifdef FF_SAT_E
100 if(!cl OR (stat NEQ -1 AND stat > SATC_ENA_CL_E))
101 #else
102 if(!cl OR (stat NEQ -1 AND stat > 1))
103 #endif
104 {
105 cmdCmeError(CME_ERR_OpNotAllow);
106 return(ATI_FAIL);
107 }
108
109 if( stat NEQ -1 )
110 {
111 sat[srcId] = (UBYTE)stat;
112 }
113
114 if( lenPrflStr )
115 {
116 utl_hexToGsm( satPrflStr, lenPrflStr, satPrflStr, &lenPrfl, GSM_ALPHA_Def,
117 CSCS_ALPHA_Reserved );
118
119 #ifdef FF_ATI_BAT
120 {
121 T_BAT_cmd_send cmd;
122 T_BAT_cmd_set_percent_satc my_bat_set_percent_satc = {0};
123 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
124
125 TRACE_FUNCTION("setatPercentSATC() calls bat_send() <=== as APPLICATION");
126
127 cmd.ctrl_params = BAT_CMD_SET_PERCENT_SATC;
128 cmd.params.ptr_set_percent_satc = &my_bat_set_percent_satc;
129
130 /* Copy and trucate if necessary the satcmd string */
131 if(my_bat_set_percent_satc.c_satprfl = (U8)lenPrfl)
132 {
133 memcpy(my_bat_set_percent_satc.satprfl,
134 satPrflStr,
135 my_bat_set_percent_satc.c_satprfl <= BAT_MAX_CPIN_PIN_LEN ?
136 my_bat_set_percent_satc.c_satprfl : BAT_MAX_CPIN_PIN_LEN);
137 }
138
139 src_params->curAtCmd = AT_CMD_SATC;
140
141 bat_send(ati_bat_get_client(srcId), &cmd);
142 return ATI_EXCT; /* executing, because response is passed by callback function */
143 }
144
145 #else /* no FF_ATI_BAT */
146
147 TRACE_FUNCTION("setatPercentSATC");
148
149 ret = sAT_PercentSATC( (T_ACI_CMD_SRC)srcId, lenPrfl, satPrflStr );
150 if (ret EQ AT_FAIL)
151 {
152 cmdCmeError(CME_ERR_Unknown);
153 }
154 return (map_aci_2_ati_rslt(ret));
155 #endif /* no FF_ATI_BAT */
156 }
157 return(ATI_CMPL);
158 }
159
160 GLOBAL T_ATI_RSLT tesatPercentSATC(char *cl, UBYTE srcId)
161 {
162 TRACE_FUNCTION("tesatPercentSATC");
163
164 sprintf(g_sa,"%s: (0,1),(%d)", "%SATC", MAX_STK_PRF*2);
165 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
166 return ATI_CMPL;
167 }
168
169 GLOBAL T_ATI_RSLT queatPercentSATC(char *cl, UBYTE srcId)
170 {
171 #ifdef FF_ATI_BAT
172
173 T_BAT_cmd_send cmd;
174 T_BAT_no_parameter dummy;
175
176 TRACE_FUNCTION("queatPercentSATC() calls bat_send() <=== as APPLICATION");
177
178 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_SATC;
179 dummy.bat_dummy = 0xFF;
180 cmd.params.ptr_que_percent_satc = &dummy;
181 bat_send(ati_bat_get_client(srcId), &cmd);
182 return ATI_EXCT; /* executing, because response is passed by callback function */
183
184 #else /* no FF_ATI_BAT */
185
186 T_ACI_RETURN ret = AT_FAIL;
187 USHORT lenPrfl = 0;
188 UBYTE satPrfl[MAX_STK_PRF];
189 UBYTE i;
190
191 TRACE_FUNCTION("queatPercentSATC");
192
193 ret = qAT_PercentSATC((T_ACI_CMD_SRC)srcId,(SHORT*)&lenPrfl, satPrfl);
194 if (ret EQ AT_CMPL)
195 {
196 i=sprintf(g_sa,"%s: %d,\"", "%SATC", sat[srcId]);
197
198 if (lenPrfl)
199 {
200 utl_binToHex( satPrfl, lenPrfl, g_sa +i );
201 }
202
203 i+=lenPrfl*2;
204 g_sa[i++]='"';
205 g_sa[i]='\0';
206
207 ci_remTrailCom(g_sa,(USHORT)strlen(g_sa));
208 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
209 }
210 else
211 {
212 cmdCmeError(CME_ERR_Unknown);
213 }
214 return (map_aci_2_ati_rslt(ret));
215
216 #endif /* no FF_ATI_BAT */
217 }
218
219 /*
220 +--------------------------------------------------------------------+
221 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
222 | STATE : code ROUTINE : atPercentSATE |
223 +--------------------------------------------------------------------+
224
225 PURPOSE : %SATE Send SAT envelope command
226 */
227 GLOBAL T_ATI_RSLT atPercentSATE(char *cl, UBYTE srcId)
228 {
229 T_ACI_RETURN ret = AT_FAIL;
230 UBYTE *satCmd = NULL ;
231 USHORT lenCmd = 0;
232 USHORT lenCmdStr = 0;
233 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
234
235 cl = parse(cl,"l", &lenCmdStr,&satCmd );
236
237 if(!cl)
238 {
239 cmdCmeError(CME_ERR_OpNotAllow);
240 return ATI_FAIL;
241 }
242
243 utl_hexToGsm( satCmd, lenCmdStr, satCmd, &lenCmd, GSM_ALPHA_Def,
244 CSCS_ALPHA_Reserved );
245
246 #ifdef FF_ATI_BAT
247 {
248 T_BAT_cmd_send cmd;
249 T_BAT_cmd_set_percent_sate my_bat_set_percent_sate = {0};
250
251 TRACE_FUNCTION("setatPercentSATE() calls bat_send() <=== as APPLICATION");
252
253 cmd.ctrl_params = BAT_CMD_SET_PERCENT_SATE;
254 cmd.params.ptr_set_percent_sate = &my_bat_set_percent_sate;
255
256 /* Copy and trucate if necessary the satemd string */
257 if(my_bat_set_percent_sate.c_satcmd = (U8)lenCmd)
258 {
259 memcpy(my_bat_set_percent_sate.satcmd,
260 satCmd,
261 my_bat_set_percent_sate.c_satcmd <= BAT_MAX_STK_CMD ?
262 my_bat_set_percent_sate.c_satcmd : BAT_MAX_STK_CMD);
263 }
264
265 src_params->curAtCmd = AT_CMD_SATE;
266
267 bat_send(ati_bat_get_client(srcId), &cmd);
268 return ATI_EXCT; /* executing, because response is passed by callback function */
269 }
270
271 #else /* no FF_ATI_BAT */
272
273 TRACE_FUNCTION("atPercentSATE");
274
275 ret = sAT_PercentSATE( (T_ACI_CMD_SRC)srcId, lenCmd, satCmd );
276 if (ret EQ AT_EXCT)
277 {
278 src_params->curAtCmd = AT_CMD_SATE;
279 }
280 if (ret EQ AT_FAIL)
281 {
282 cmdCmeError(CME_ERR_Unknown);
283 }
284 return (map_aci_2_ati_rslt(ret));
285 #endif /* no FF_ATI_BAT */
286 }
287
288 /*
289 +--------------------------------------------------------------------+
290 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
291 | STATE : code ROUTINE : atPercentSATR |
292 +--------------------------------------------------------------------+
293
294 PURPOSE : %SATE Send SAT command response
295 */
296 GLOBAL T_ATI_RSLT atPercentSATR(char *cl, UBYTE srcId)
297 {
298 T_ACI_RETURN ret = AT_FAIL;
299 UBYTE *satRsp = NULL ;
300 USHORT lenRsp = 0;
301 USHORT lenRspStr = 0;
302
303 cl = parse(cl,"l", &lenRspStr,&satRsp );
304
305 if(!cl)
306 {
307 cmdCmeError(CME_ERR_OpNotAllow);
308 return ATI_FAIL;
309 }
310
311 utl_hexToGsm( satRsp, lenRspStr, satRsp, &lenRsp, GSM_ALPHA_Def,
312 CSCS_ALPHA_Reserved );
313
314 #ifdef FF_ATI_BAT
315 {
316 T_BAT_cmd_send cmd;
317 T_BAT_cmd_set_percent_satr my_bat_set_percent_satr = {0};
318 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
319
320 TRACE_FUNCTION("setatPercentSATR() calls bat_send() <=== as APPLICATION");
321
322 cmd.ctrl_params = BAT_CMD_SET_PERCENT_SATR;
323 cmd.params.ptr_set_percent_satr = &my_bat_set_percent_satr;
324
325 /* Copy and trucate if necessary the satrmd string */
326 if(my_bat_set_percent_satr.c_satrsp = (U8)lenRsp)
327 {
328 memcpy(my_bat_set_percent_satr.satrsp,
329 satRsp,
330 my_bat_set_percent_satr.c_satrsp <= BAT_MAX_STK_CMD ?
331 my_bat_set_percent_satr.c_satrsp : BAT_MAX_STK_CMD);
332 }
333
334 src_params->curAtCmd = AT_CMD_SATR;
335
336 bat_send(ati_bat_get_client(srcId), &cmd);
337 return ATI_EXCT; /* executing, because response is passed by callback function */
338 }
339
340 #else /* no FF_ATI_BAT */
341
342 TRACE_FUNCTION("atPercentSATR");
343
344 ret = sAT_PercentSATR((T_ACI_CMD_SRC)srcId, lenRsp, satRsp );
345
346 if (ret NEQ AT_CMPL)
347 {
348 cmdCmeError(CME_ERR_Unknown);
349 }
350 return (map_aci_2_ati_rslt(ret));
351 #endif /* no FF_ATI_BAT */
352 }
353
354 /*
355 +--------------------------------------------------------------------+
356 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
357 | STATE : code ROUTINE : atPercentSATT |
358 +--------------------------------------------------------------------+
359
360 PURPOSE : %SATT Terminate SAT command or session
361 */
362 GLOBAL T_ATI_RSLT atPercentSATT(char *cl, UBYTE srcId)
363 {
364 T_ACI_RETURN ret = AT_FAIL;
365 T_ACI_SATT_CS cs = SATT_CS_NotPresent;
366
367
368 cl = parse(cl,"d", &cs );
369 if(!cl)
370 {
371 cmdCmeError(CME_ERR_OpNotAllow);
372 return ATI_FAIL;
373 }
374
375 #ifdef FF_ATI_BAT
376 {
377 T_BAT_cmd_send cmd;
378 T_BAT_cmd_set_percent_satt my_bat_set_percent_satt = {0};
379 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
380
381 TRACE_FUNCTION("setatPercentSATT() calls bat_send() <=== as APPLICATION");
382
383 cmd.ctrl_params = BAT_CMD_SET_PERCENT_SATT;
384 cmd.params.ptr_set_percent_satt = &my_bat_set_percent_satt;
385
386 my_bat_set_percent_satt.cs = (T_BAT_percent_satt_cs)cs;
387
388 src_params->curAtCmd = AT_CMD_SATT;
389
390 bat_send(ati_bat_get_client(srcId), &cmd);
391 return ATI_EXCT; /* executing, because response is passed by callback function */
392 }
393
394 #else /* no FF_ATI_BAT */
395
396 TRACE_FUNCTION("atPercentSATT");
397
398 ret = sAT_PercentSATT( (T_ACI_CMD_SRC)srcId, cs );
399
400 if (ret NEQ AT_CMPL)
401 {
402 cmdCmeError(CME_ERR_Unknown);
403 }
404 return (map_aci_2_ati_rslt(ret));
405 #endif /* no FF_ATI_BAT */
406 }
407
408 /*
409 +--------------------------------------------------------------------+
410 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
411 | STATE : code ROUTINE : setatPercentEFRSLT |
412 +--------------------------------------------------------------------+
413
414 PURPOSE : %EFRSLT Response to EF update indication
415 */
416 GLOBAL T_ATI_RSLT setatPercentEFRSLT(char *cl,UBYTE srcId)
417 {
418 T_ACI_EFRSLT_RES res;
419 T_ACI_RETURN ret;
420
421 TRACE_FUNCTION("setatPercentEFRSLT()");
422
423 switch(*cl)
424 {
425 case '0':
426 res=EFRSLT_RES_FAIL;
427 break;
428
429 case '1':
430 res=EFRSLT_RES_OK;
431 break;
432
433 default:
434 cmdCmeError(CME_ERR_OpNotSupp);
435 return(ATI_FAIL);
436 }
437
438 #ifdef FF_ATI_BAT
439
440 {
441 T_BAT_cmd_send cmd;
442 T_BAT_cmd_set_percent_efrslt efrslt;
443
444 cmd.ctrl_params=BAT_CMD_SET_PERCENT_EFRSLT;
445 cmd.params.ptr_set_percent_efrslt=&efrslt;
446
447 /*
448 * This relies on T_BAT_percent_efrslt_result and T_ACI_EFRSLT_RES
449 * being identical.
450 */
451 efrslt.result=(T_BAT_percent_efrslt_result)res;
452
453 bat_send(ati_bat_get_client(srcId),&cmd);
454 return(ATI_EXCT);
455 }
456
457 #else
458
459 ret=sAT_PercentEFRSLT((T_ACI_CMD_SRC)srcId,res);
460 return(map_aci_2_ati_rslt(ret));
461
462 #endif /*FF_ATI_BAT*/
463 }
464
465
466 /*
467 +--------------------------------------------------------------------+
468 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
469 | STATE : code ROUTINE : setatPercentSIMEF |
470 +--------------------------------------------------------------------+
471
472 PURPOSE : %SIMEF Receive notification of EF updates
473 */
474 GLOBAL T_ATI_RSLT setatPercentSIMEF(char *cl,UBYTE srcId)
475 {
476 T_ACI_SIMEF_MODE mode;
477 T_ACI_RETURN ret;
478
479 TRACE_FUNCTION("setatPercentSIMEF()");
480
481 switch(*cl)
482 {
483 case '0':
484 mode=SIMEF_MODE_OFF;
485 break;
486
487 case '1':
488 mode=SIMEF_MODE_ON;
489 break;
490
491 default:
492 cmdCmeError(CME_ERR_OpNotSupp);
493 return(ATI_FAIL);
494 }
495 #ifdef FF_ATI_BAT
496
497 {
498 T_BAT_cmd_send cmd;
499 T_BAT_cmd_set_percent_simef simef;
500
501 cmd.ctrl_params=BAT_CMD_SET_PERCENT_SIMEF;
502 cmd.params.ptr_set_percent_simef=&simef;
503
504 /*
505 * This relies on T_BAT_percent_simef_mode and T_ACI_SIMEF_MODE
506 * being identical.
507 */
508 simef.mode = (T_BAT_percent_simef_mode)mode;
509
510 bat_send(ati_bat_get_client(srcId),&cmd);
511 return(ATI_EXCT);
512 }
513
514 #else
515 ret=sAT_PercentSIMEF((T_ACI_CMD_SRC)srcId,mode);
516
517 return(map_aci_2_ati_rslt(ret));
518 #endif /*FF_ATI_BAT*/
519 }
520
521
522 /*
523 +--------------------------------------------------------------------+
524 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
525 | STATE : code ROUTINE : queatPercentSIMEF |
526 +--------------------------------------------------------------------+
527
528 PURPOSE : %SIMEF Receive notification of EF updates
529 */
530 GLOBAL T_ATI_RSLT queatPercentSIMEF(char *cl, UBYTE srcId)
531 {
532 #ifdef FF_ATI_BAT
533
534 T_BAT_cmd_send cmd;
535 T_BAT_no_parameter dummy;
536
537 TRACE_FUNCTION("queatPercentSIMEF() calls bat_send() <=== as APPLICATION");
538
539 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_SIMEF;
540 dummy.bat_dummy = 0xFF;
541 cmd.params.ptr_que_percent_simef = &dummy;
542 bat_send(ati_bat_get_client(srcId), &cmd);
543 return ATI_EXCT; /* executing, because response is passed by callback function */
544
545 #else /* no FF_ATI_BAT */
546 T_ACI_RETURN ret;
547 T_ACI_SIMEF_MODE mode;
548
549 TRACE_FUNCTION("queatPercentSIMEF");
550
551 ret=qAT_PercentSIMEF((T_ACI_CMD_SRC)srcId,&mode);
552
553 if (ret EQ AT_CMPL)
554 {
555 sprintf(g_sa,"%s: %d","%SIMEF",mode);
556 io_sendMessage(srcId,g_sa,ATI_NORMAL_OUTPUT);
557 }
558
559 return(map_aci_2_ati_rslt(ret));
560 #endif /* no FF_ATI_BAT */
561 }
562
563
564 /*
565 +--------------------------------------------------------------------+
566 | PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
567 | STATE : code ROUTINE : handle_rCI_PercentSATx |
568 +--------------------------------------------------------------------+
569
570 PURPOSE : handles chunked output for several rCI_PercentSAT functions
571 */
572
573 LOCAL void handle_rCI_PercentSATx ( CHAR *prefix,
574 SHORT len,
575 UBYTE *satCmd,
576 T_ACI_SATN_CNTRL_TYPE cntrl_type)
577 {
578 SHORT i;
579 UBYTE srcId = srcId_cb;
580 SHORT chunksize;
581 T_ATI_OUTPUT_TYPE output_type =(T_ATI_OUTPUT_TYPE) (ATI_INDICATION_OUTPUT |
582 ATI_BEGIN_CRLF_OUTPUT);
583
584 if( sat[srcId] )
585 {
586 i=sprintf(g_sa, "%s: \"", prefix);
587 do
588 {
589 chunksize = (sizeof(g_sa)-i-2)/2; /* -2 for '"' and '\0' at the end, /2 since we occupy two bytes after binToHex */
590
591 if (cntrl_type NEQ SATN_CNTRL_BY_SIM_Not_Present)
592 {
593 chunksize -= 2; /* Take another 2 characters off for the ,<cntrl_type> */
594 }
595 chunksize = MINIMUM(len, chunksize);
596
597 utl_binToHex( satCmd, chunksize, g_sa+i );
598
599 if ((len -= chunksize) EQ 0)
600 {
601 /* end reached? then append CRLF to the last output */
602 output_type |= ATI_END_CRLF_OUTPUT;
603
604 i+=2*chunksize;
605
606 g_sa[i++]='"'; /* closing quotation marks */
607
608 /*
609 ** Add the control type onto the end, if given
610 */
611 if (cntrl_type NEQ SATN_CNTRL_BY_SIM_Not_Present)
612 {
613 g_sa[i++] = ',';
614 switch(cntrl_type)
615 {
616 case SATN_CNTRL_BY_SIM_CALL:
617 g_sa[i++] = '0';
618 break;
619
620 case SATN_CNTRL_BY_SIM_SS:
621 g_sa[i++] = '1';
622 break;
623
624 case SATN_CNTRL_BY_SIM_USSD:
625 g_sa[i++] = '2';
626 break;
627
628 case SATN_CNTRL_BY_SIM_SMS:
629 g_sa[i++] = '3';
630 break;
631
632 default:
633 i--;
634 break;
635 }
636
637 }
638
639 g_sa[i]='\0';
640 }
641
642 io_sendMessageEx(srcId, g_sa, output_type);
643
644 /* remove the BEGIN_CRLF for the next possible chunk */
645 output_type &= (T_ATI_OUTPUT_TYPE)~ATI_BEGIN_CRLF_OUTPUT;
646
647 g_sa[0] = '\0';
648 i=0;
649 satCmd += chunksize;
650 } while (len);
651 }
652 }
653
654
655 /*
656 +--------------------------------------------------------------------+
657 | PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
658 | STATE : code ROUTINE : rCI_PercentSATI |
659 +--------------------------------------------------------------------+
660
661 PURPOSE : handles AT_PercentSATI call back
662
663 */
664
665 GLOBAL void rCI_PercentSATI ( /*UBYTE srcId,*/
666 SHORT len,
667 UBYTE *satCmd)
668 {
669 TRACE_FUNCTION("rCI_PercentSATI()");
670 handle_rCI_PercentSATx ("%SATI", len, satCmd, SATN_CNTRL_BY_SIM_Not_Present);
671 }
672
673 /*
674 +--------------------------------------------------------------------+
675 | PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
676 | STATE : code ROUTINE : rCI_PercentSATE |
677 +--------------------------------------------------------------------+
678
679 PURPOSE : handles AT_PercentSATE call back
680
681 */
682
683 GLOBAL void rCI_PercentSATE ( /*UBYTE srcId,*/
684 SHORT len,
685 UBYTE *satCmd)
686 {
687 TRACE_FUNCTION("rCI_PercentSATE()");
688 handle_rCI_PercentSATx ("%SATE", len, satCmd, SATN_CNTRL_BY_SIM_Not_Present);
689 }
690
691 /*
692 +--------------------------------------------------------------------+
693 | PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
694 | STATE : code ROUTINE : rCI_PercentSATN |
695 +--------------------------------------------------------------------+
696
697 PURPOSE : handles AT_PercentSATN call back
698
699 */
700
701 GLOBAL void rCI_PercentSATN ( /*UBYTE srcId,*/
702 SHORT len,
703 UBYTE *satCmd,
704 T_ACI_SATN_CNTRL_TYPE cntrl_type)
705 {
706 UBYTE srcId = srcId_cb;
707
708 TRACE_FUNCTION("rCI_PercentSATN()");
709
710 if(srcId NEQ run_at_id)
711 {
712 handle_rCI_PercentSATx ("%SATN", len, satCmd, cntrl_type);
713 }
714 }
715
716 /*
717 +--------------------------------------------------------------------+
718 | PROJECT : GSM-F&D (8411) MODULE : ACI_RET |
719 | STATE : code ROUTINE : rCI_PercentSATA |
720 +--------------------------------------------------------------------+
721
722 PURPOSE : handles AT_PercentSATA call back
723
724 */
725
726 #ifdef FF_SAT_E
727 GLOBAL void rCI_PercentSATA ( /*UBYTE srcId,*/
728 SHORT cId,
729 LONG rdlTimeout_ms,
730 T_ACI_SATA_ADD *addParm )
731 #else
732 GLOBAL void rCI_PercentSATA ( /*UBYTE srcId,*/
733 SHORT cId,
734 LONG rdlTimeout_ms)
735 #endif /* FF_SAT_E */
736 {
737 UBYTE i;
738 UBYTE srcId = srcId_cb;
739
740 TRACE_FUNCTION("rCI_PercentSATA()");
741
742 if( sat[srcId] )
743 {
744 i=sprintf(g_sa,"%s: ","%SATA");
745
746 if(rdlTimeout_ms NEQ ACI_NumParmNotPresent)
747 {
748 i+=sprintf( g_sa+i, "%d", rdlTimeout_ms );
749 }
750
751 #ifdef FF_SAT_E
752 if( sat[srcId] EQ SATC_ENA_CL_E )
753 {
754 sprintf( g_sa+i, ",%d,%d", addParm->chnType, addParm->chnEst );
755 }
756 #endif /* FF_SAT_E */
757
758 io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
759 }
760 }
761
762 #endif /* ATI_SAT_C */
763
764 #endif /* #ifdef SIM_TOOLKIT */
765