FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/ati_csc.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: CONDAT specific commands.
18 +-----------------------------------------------------------------------------
19 */
20
21 #ifndef ATI_CSC_C
22 #define ATI_CSC_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 #if defined(FF_WAP) || defined(FF_PPP) || defined(FF_GPF_TCPIP) || defined (FF_SAT_E)
40 #include "dti.h" /* functionality of the dti library */
41 #include "dti_conn_mng.h"
42 #include "wap_aci.h"
43 #include "psa_ppp_w.h"
44 #endif /* FF_WAP || FF_PPP || FF_GPF_TCPIP || FF_SAT_E */
45
46 #include "aci_mem.h"
47 #include "ati_cmd.h"
48 #include "aci_lst.h"
49 #include "aci_prs.h"
50
51 #include "psa_mmi.h"
52
53 #include "ati_int.h"
54
55 /* only needed for testing AT%DAR=5 */
56 /*
57 #include "aci.h"
58 */
59
60 #ifdef FF_ATI_BAT
61
62 #include "typedefs.h"
63 #include "gdd.h"
64 #include "bat.h"
65
66 #include "ati_bat.h"
67
68 #endif /* FF_ATI_BAT */
69 EXTERN UBYTE std;
70
71 typedef struct
72 {
73 char *name;
74 T_ACI_CUSCFG_FAC fac;
75 } cuscfg_fac;
76
77 const cuscfg_fac cus_fac[] =
78 {
79 {"CCMOSM", CUSCFG_FAC_MO_SM_Control},
80 {"CCMOC", CUSCFG_FAC_MO_Call_Control},
81 {"CCMOSS", CUSCFG_FAC_MO_SS_Control},
82 {"CCMOUSSD", CUSCFG_FAC_MO_USSD_Control},
83 {"2BDIAL", CUSCFG_FAC_2_Digit_Call},
84 {"EUSSDR", CUSCFG_FAC_Ext_USSD_Res},
85 {"ETMOBEONSR", CUSCFG_FAC_T_MOBILE_Eons},
86 {"USSDASMOC", CUSCFG_FAC_USSD_As_MO_Call},
87 {0, CUSCFG_FAC_Not_Present}
88 };
89
90 #define MAX_FAC_STR_LENGTH 20
91 #define MAX_VALUE_LENGTH MAX_FAC_STR_LENGTH
92
93
94 /*
95 +--------------------------------------------------------------------+
96 | PROJECT : GSM-PS MODULE : CMH_MMIS |
97 | STATE : code ROUTINE : atPercentCPRIM |
98 +--------------------------------------------------------------------+
99
100 PURPOSE : This is the functional counterpart to the %CPRIM AT command
101 which is used to send a system primitive (CONFIG PRIMITIVE)
102 to a entity or frame.
103 */
104
105 GLOBAL T_ATI_RSLT atPercentCPRIM (char *cl, UBYTE srcId)
106 {
107 char receiver_name[10];
108 char config_str[80];
109 T_HANDLE receiver_handle;
110
111 TRACE_FUNCTION ("atPercentCPRIM()");
112
113 *receiver_name = '\0';
114 *config_str = '\0';
115
116 cl = parse(cl, "ss", (LONG)sizeof (receiver_name), receiver_name,
117 (LONG)sizeof (config_str), config_str);
118
119 if(!cl)
120 {
121 cmdCmeError(CME_ERR_OpNotAllow);
122 TRACE_EVENT ("atPercentCPRIM(): parse error");
123 return (ATI_FAIL);
124 }
125
126 receiver_handle = vsi_c_open (VSI_CALLER receiver_name);
127 if (receiver_handle < VSI_OK)
128 {
129 cmdCmeError(CME_ERR_OpNotAllow);
130 TRACE_EVENT_P1 ("atPercentCPRIM(): wrong entity [%s]", receiver_name);
131 return (ATI_FAIL);
132 }
133
134 psaMMI_ConfigPrim (receiver_handle, config_str);
135
136 vsi_c_close (VSI_CALLER receiver_handle);
137
138 return (ATI_CMPL);
139 }
140
141 /*
142 +--------------------------------------------------------------------+
143 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
144 | STATE : code ROUTINE : atPercentBAND |
145 +--------------------------------------------------------------------+
146
147 PURPOSE : %BAND multiband configuration command
148 */
149
150 GLOBAL T_ATI_RSLT setatPercentBAND (CHAR *cl, UBYTE srcId)
151 {
152 T_ACI_BAND_MODE bandMode;
153 USHORT ushort_bandType = 0xFFFF; /* ushort because of parser **##!!## */
154 T_ACI_RETURN ret = AT_FAIL;
155 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
156
157 src_params->curAtCmd = AT_CMD_BAND;
158
159 cl = parse(cl,"dr",&bandMode,&ushort_bandType);
160 if (cl EQ NULL)
161 {
162 cmdCmeError(CME_ERR_OpNotAllow);
163 return (ATI_FAIL);
164 }
165
166 /* prechecking: only place where consistence can be checked (whether
167 bandType parameter is present or not) */
168 if( bandMode EQ BAND_MODE_Manual AND
169 ( (ushort_bandType & 0xFF00) NEQ 0x0000) )
170 {
171 TRACE_EVENT("Error: AT%%BAND manual mode but no bands chosen");
172 cmdCmeError(CME_ERR_OpNotAllow);
173 return (ATI_FAIL);
174 }
175 else if( bandMode EQ BAND_MODE_Auto AND
176 ushort_bandType NEQ 0xFFFF )
177 {
178 TRACE_EVENT("Error: AT%%BAND auto mode but band type has been given: inconsistent");
179 cmdCmeError(CME_ERR_OpNotAllow);
180 return (ATI_FAIL);
181 }
182
183 TRACE_EVENT_P1("ushort_bandType: %04X", ushort_bandType);
184 TRACE_EVENT_P1("bandMode: %d", bandMode);
185
186 #ifdef FF_ATI_BAT
187 {
188 T_BAT_cmd_send cmd;
189 T_BAT_cmd_set_percent_band my_bat_set_percent_band;
190
191 TRACE_FUNCTION("setatPercentBAND() calls bat_send() <=== as APPLICATION");
192
193 memset(&my_bat_set_percent_band, 0, sizeof(my_bat_set_percent_band));
194 cmd.ctrl_params = BAT_CMD_SET_PERCENT_BAND;
195 cmd.params.ptr_set_percent_band = &my_bat_set_percent_band;
196
197 my_bat_set_percent_band.mode = bandMode;
198 my_bat_set_percent_band.band = ushort_bandType;
199
200 bat_send(ati_bat_get_client(srcId), &cmd);
201
202 return ATI_EXCT; /* executing, because response is passed by callback function */
203 }
204 #else /* OLD FUNCTION BODY */
205
206 TRACE_FUNCTION("setatPercentBAND()");
207
208 ret = sAT_PercentBAND((T_ACI_CMD_SRC)srcId, bandMode, (UBYTE)ushort_bandType);
209
210 switch (ret)
211 {
212 case (AT_CMPL):
213 break;
214
215 case (AT_EXCT):
216 break;
217
218 default:
219 cmdCmeError(CME_ERR_Unknown);
220 break;
221 }
222 return (map_aci_2_ati_rslt(ret));
223
224 #endif /* no FF_ATI_BAT*/
225 }
226
227 /* at the moment 5 levels of bands are supported */
228 /* BITS: | 5 | 4 | 3 | 2 | 1 |
229 | GSM850 | E_GSM | GSM1900 | GSM1800 | GSM900 | */
230 #define HIGHEST_BAND_SUPPORTED (0x1F)
231
232 GLOBAL T_ATI_RSLT tesatPercentBAND (CHAR *cl, UBYTE srcId)
233 {
234 T_ACI_BAND_MODE MaxBandMode;
235 UBYTE bands_bitfield;
236 T_ACI_RETURN ret = AT_FAIL;
237 UBYTE c_set_bit = 0;
238 USHORT pos = 0;
239 UBYTE i, tested_filter_byte, highest_set_bit_only=0;
240
241 TRACE_FUNCTION("tesatPercentBAND()");
242
243
244 ret = tAT_PercentBAND( (T_ACI_CMD_SRC)srcId,
245 &MaxBandMode,
246 &bands_bitfield);
247
248 if( ret NEQ AT_CMPL )
249 {
250 cmdCmeError(CME_ERR_Unknown);
251 return (ATI_CMPL);
252 }
253
254 /* initialization of the string */
255 pos += sprintf(g_sa, "%s: (0-%d)", "%BAND", MaxBandMode);
256 pos += sprintf( g_sa+pos, ",(" );
257
258 if(bands_bitfield EQ 0x00)
259 {
260 /* no particular settings from manufacturer */
261 pos += sprintf( g_sa+pos, "1-%d)", HIGHEST_BAND_SUPPORTED );
262 }
263 else
264 {
265 /* search holes between highest bit and lowest bit */
266 for( i=0; i<8 ; i++ )
267 {
268 tested_filter_byte = 0x01 << i;
269
270 if( (bands_bitfield & tested_filter_byte) )
271 {
272 highest_set_bit_only = tested_filter_byte;
273 c_set_bit++;
274 }
275 }
276
277 if(c_set_bit) /* alignment at the end */
278 {
279 c_set_bit--;
280 }
281
282 if( highest_set_bit_only EQ (0x01 << c_set_bit) )
283 {
284 /* there is no hole in the supported values, form 1 to max_value */
285 pos += sprintf( g_sa+pos, "1-%d)", bands_bitfield );
286 }
287 else
288 {
289 for(i=1 ; i<=bands_bitfield; i++) /* bands_bitfield is obviously the highest possible value */
290 {
291 if( (i & bands_bitfield) EQ i )
292 {
293 pos += sprintf( g_sa+pos, "%d,", i);
294 }
295 if(pos>MAX_CMD_LEN-5) /* -5 to have some buffer */
296 {
297 TRACE_EVENT("output buffer is too short !!!");
298 break;
299 }
300 }
301 pos--; /* erase last comma */
302 sprintf( g_sa+pos, ")");
303 }
304 }
305
306 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
307
308 return (ATI_CMPL);
309 }
310
311 GLOBAL T_ATI_RSLT queatPercentBAND (CHAR *cl, UBYTE srcId)
312 {
313 T_ACI_BAND_MODE bandMode;
314 UBYTE bandType;
315 T_ACI_RETURN ret = AT_FAIL;
316
317 TRACE_FUNCTION("queatPercentBAND()");
318
319 ret = qAT_PercentBAND((T_ACI_CMD_SRC)srcId, &bandMode, &bandType);
320
321 if (ret NEQ AT_CMPL)
322 {
323 cmdCmeError(CME_ERR_Unknown);
324 return (ATI_FAIL);
325 }
326
327 if( bandType EQ 0x00
328 OR bandMode EQ BAND_MODE_Auto )
329 {
330 sprintf(g_sa, "%s: %d", "%BAND", bandMode);
331 }
332 else
333 {
334 sprintf(g_sa, "%s: %d,%d", "%BAND", bandMode, bandType);
335 }
336
337 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
338
339 return (ATI_CMPL);
340 }
341
342 /*
343 +--------------------------------------------------------------------+
344 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
345 | STATE : code ROUTINE : atPercentNRG |
346 +--------------------------------------------------------------------+
347
348 PURPOSE : %NRG extendet registration command
349 */
350
351 GLOBAL T_ATI_RSLT setatPercentNRG (char *cl, UBYTE srcId)
352 {
353 char op[MAX_ALPHA_OPER_LEN]={""};
354 T_ACI_RETURN ret = AT_FAIL;
355 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
356 T_ACI_NRG_RGMD regMode = NRG_RGMD_NotPresent;
357 T_ACI_NRG_SVMD srvMode = NRG_SVMD_NotPresent;
358 T_ACI_NRG_FRMT oprFrmt = NRG_FRMT_NotPresent;
359
360 TRACE_FUNCTION("setatPercentNRG()");
361
362 /* split parameter string in int,int,int,str */
363 cl = parse(cl,"ddds",&regMode,&srvMode,&oprFrmt,(LONG)20,op);
364 if (!cl)
365 {
366 cmdCmeError(CME_ERR_OpNotAllow);
367 return (ATI_FAIL);
368 }
369
370 ret = sAT_PercentNRG((T_ACI_CMD_SRC)srcId,regMode,srvMode,oprFrmt,op);
371
372 switch (ret)
373 {
374 case (AT_CMPL): /*operation completed*/
375 break;
376 case (AT_EXCT):
377 src_params->curAtCmd = AT_CMD_NRG;
378 break;
379 default:
380 cmdCmeError(CME_ERR_Unknown); /*Command failed*/
381 break;
382 }
383 return (map_aci_2_ati_rslt(ret));
384 }
385
386
387 GLOBAL T_ATI_RSLT queatPercentNRG (char *cl, UBYTE srcId)
388 {
389 char op[MAX_ALPHA_OPER_LEN];
390 T_ACI_RETURN ret = AT_FAIL;
391 T_ACI_NRG_RGMD regMode= NRG_RGMD_NotPresent;
392 T_ACI_NRG_SVMD srvMode= NRG_SVMD_NotPresent;
393 T_ACI_NRG_SVMD srvStat= NRG_SVMD_NotPresent;
394 T_ACI_NRG_FRMT oprFrmt= NRG_FRMT_NotPresent;
395
396 TRACE_FUNCTION("queatPercentNRG()");
397
398 ret = qAT_PercentNRG((T_ACI_CMD_SRC)srcId,&regMode,&srvMode,
399 &oprFrmt,&srvStat,op);
400 if (ret EQ AT_CMPL)
401 {
402 if( *op )
403 sprintf(g_sa,"%s: %d,%d,%d,%d,\"%s\"", "%NRG", regMode,srvMode,oprFrmt,srvStat,op);
404 else
405 sprintf(g_sa,"%s: %d,%d,,%d", "%NRG", regMode,srvMode,srvStat);
406
407 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
408 }
409 else
410 {
411 cmdCmeError(CME_ERR_Unknown); /*command failed*/
412 }
413 return (map_aci_2_ati_rslt(ret));
414 }
415
416
417 /*
418 +--------------------------------------------------------------------+
419 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
420 | STATE : code ROUTINE : atPercentCAOC |
421 +--------------------------------------------------------------------+
422
423 PURPOSE : %CAOC / %CACM command (Advice of Charge)
424 */
425 LOCAL T_ATI_RSLT QueryCCM_ACM(CHAR *cl,T_ACI_AT_CMD cmd, UBYTE srcId)
426 {
427 char currency [MAX_CUR_LEN] = {0x00};
428 char cvtdCurrency [2*MAX_CUR_LEN] = {0x00};
429 USHORT lenCvtdCurrency = 0;
430 USHORT pos = 0;
431 char ppu [MAX_PPU_LENGTH] = {0x00};
432 T_ACI_RETURN ret = AT_FAIL;
433
434 switch(cmd)
435 {
436 case(AT_CMD_CAOC ):
437 /*
438 * AT%CAOC queries the actual ccm value using PUCT
439 */
440 ret = qAT_PercentCAOC((T_ACI_CMD_SRC)srcId, currency, ppu);
441 pos = sprintf(g_sa,"%s: ","%CAOC");
442 break;
443 case(AT_CMD_CACM):
444 /*
445 * AT%CACM requests the ACM using PUCT.
446 */
447 ret = qAT_PercentCACM((T_ACI_CMD_SRC)srcId,currency,ppu);
448 pos = sprintf(g_sa,"%s: ","%CACM");
449 break;
450 }
451
452 if( ret NEQ AT_CMPL )
453 {
454 cmdCmeError(CME_ERR_Unknown);
455 return (ATI_FAIL);
456 }
457
458 srcId_cb = srcId;
459 utl_chsetFromGsm((UBYTE*)currency,
460 (USHORT)strlen(currency),
461 (UBYTE*)cvtdCurrency,
462 sizeof(cvtdCurrency),
463 &lenCvtdCurrency,
464 GSM_ALPHA_Def);
465 pos+=sprints(g_sa+pos,cvtdCurrency,lenCvtdCurrency);
466 pos+=sprintf(g_sa+pos,",\"%s\"",ppu);
467 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
468 return (map_aci_2_ati_rslt(ret));
469 }
470
471
472 GLOBAL T_ATI_RSLT atPercentCAOC (char* cl, UBYTE srcId)
473 {
474 TRACE_FUNCTION("atPercentCAOC()");
475
476 return(QueryCCM_ACM(cl,AT_CMD_CAOC,srcId));
477 }
478
479 /*
480 +--------------------------------------------------------------------+
481 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
482 | STATE : code ROUTINE : atPercentCACM |
483 +--------------------------------------------------------------------+
484
485 PURPOSE : %CACM command (Advice of Charge, Accumulated Call Meter)
486 */
487 GLOBAL T_ATI_RSLT atPercentCACM (char* cl, UBYTE srcId)
488 {
489 TRACE_FUNCTION("atPercentCACM()");
490
491 return(QueryCCM_ACM(cl,AT_CMD_CACM,srcId));
492 }
493
494 /*
495 +--------------------------------------------------------------------+
496 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
497 | STATE : code ROUTINE : atPercentCTV |
498 +--------------------------------------------------------------------+
499
500 PURPOSE : %CTV command (Current Call Timer Values)
501 */
502 GLOBAL T_ATI_RSLT atPercentCTV (char* cl, UBYTE srcId)
503 {
504 LONG ctv;
505 T_ACI_RETURN ret = AT_FAIL;
506
507 TRACE_FUNCTION("atPercentCTV()");
508
509 switch (*cl)
510 {
511 case('\0'):
512 /*
513 * AT%CTV queries the call timer value
514 */
515 ret = qAT_PercentCTV((T_ACI_CMD_SRC)srcId, &ctv);
516 if( ret NEQ AT_CMPL )
517 {
518 cmdCmeError(CME_ERR_Unknown);
519 return (ATI_FAIL);
520 }
521 resp_disp(srcId, cl,"l",&ctv);
522 break;
523
524 default:
525 cmdCmeError(CME_ERR_OpNotAllow);
526 return (ATI_FAIL);
527 }
528 return (map_aci_2_ati_rslt(ret));
529 }
530
531
532 /*
533 +--------------------------------------------------------------------+
534 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
535 | STATE : code ROUTINE : atPercentCPI |
536 +--------------------------------------------------------------------+
537
538 PURPOSE : %CPI command (Call proceeding indication)
539 */
540
541 GLOBAL T_ATI_RSLT setatPercentCPI(char *cl, UBYTE srcId)
542 {
543 SHORT mode = ACI_NumParmNotPresent;
544
545 TRACE_FUNCTION("setatPercentCPI()");
546
547 cl = parse(cl,"r",&mode);
548 if(!cl OR mode > 4 OR mode < 0)
549 {
550 cmdCmeError(CME_ERR_OpNotAllow);
551 return (ATI_FAIL);
552 }
553
554 ati_user_output_cfg[srcId].CPI_stat=(UBYTE)mode;
555 return (ATI_CMPL);
556 }
557
558 GLOBAL T_ATI_RSLT queatPercentCPI(char *cl, UBYTE srcId)
559 {
560 int value;
561
562 TRACE_FUNCTION("queatPercentCPI()");
563
564 value = (int)ati_user_output_cfg[srcId].CPI_stat;
565 resp_disp(srcId, cl,"e",&value);
566 return (ATI_CMPL);
567 }
568
569 /*
570 +--------------------------------------------------------------------+
571 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
572 | STATE : code ROUTINE : atPercentVER |
573 +--------------------------------------------------------------------+
574
575 PURPOSE : %VER displays version of entities
576 */
577
578 #if !defined (WIN32) AND !defined(_lint)
579 EXTERN CHAR* aci_version(void);
580 EXTERN CHAR* cc_version(void);
581 //EXTERN CHAR* ccd_version(void);
582 EXTERN CHAR* dl_version(void);
583 EXTERN CHAR* mm_version(void);
584 EXTERN CHAR* rr_version(void);
585 EXTERN CHAR* sim_version(void);
586 EXTERN CHAR* sms_version(void);
587 EXTERN CHAR* ss_version(void);
588 EXTERN CHAR* l1_version(void);
589 #ifdef SMI
590 EXTERN CHAR* smi_version(void);
591 #endif
592 #ifdef MFW
593 EXTERN CHAR* bmi_version(void);
594 EXTERN CHAR* mfw_version(void);
595 #endif
596 #ifdef FAX_AND_DATA
597 EXTERN CHAR* l2r_version(void);
598 EXTERN CHAR* ra_version(void);
599 EXTERN CHAR* rlp_version(void);
600 #ifdef FF_FAX
601 EXTERN CHAR* fad_version(void);
602 EXTERN CHAR* t30_version(void);
603 #endif /* FF_FAX */
604 #endif /* FAX_AND_DATA */
605 #endif
606
607 GLOBAL T_ATI_RSLT atPercentVER (char* cl, UBYTE srcId)
608 {
609 char *me="%VER: ";
610
611 TRACE_FUNCTION("atPercentVER()");
612 #if !defined (WIN32) AND !defined(_lint)
613 sprintf(g_sa,"%s%s",me,aci_version());
614 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
615 sprintf(g_sa,"%s%s",me,cc_version());
616 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
617 //sprintf(g_sa,"%s%s",me,ccd_version());
618 //io_sendMessage(g_sa, ATI_NORMAL_OUTPUT);
619 sprintf(g_sa,"%s%s",me,dl_version());
620 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
621 sprintf(g_sa,"%s%s",me,mm_version());
622 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
623 sprintf(g_sa,"%s%s",me,rr_version());
624 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
625 sprintf(g_sa,"%s%s",me,sim_version());
626 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
627 sprintf(g_sa,"%s%s",me,sms_version());
628 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
629 sprintf(g_sa,"%s%s",me,ss_version());
630 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
631 sprintf(g_sa,"%s%s",me,l1_version());
632 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
633 #ifndef NEW_FRAME
634 sprintf(g_sa,"%s%s",me,comframe_version());
635 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
636 #endif
637 #ifdef SMI
638 sprintf(g_sa,"%s%s",me,smi_version());
639 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
640 #endif
641 #ifdef MFW
642 sprintf(g_sa,"%s%s",me,bmi_version());
643 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
644 sprintf(g_sa,"%s%s",me,mfw_version());
645 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
646 #endif
647
648 #ifdef FAX_AND_DATA
649 sprintf(g_sa,"%s%s",me,l2r_version());
650 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
651 sprintf(g_sa,"%s%s",me,ra_version());
652 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
653 sprintf(g_sa,"%s%s",me,rlp_version());
654 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
655
656 #ifdef FF_FAX
657 sprintf(g_sa,"%s%s",me,fad_version());
658 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
659 sprintf(g_sa,"%s%s",me,t30_version());
660 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
661 #endif /* FF_FAX */
662
663 #endif /* FAX_AND_DATA */
664
665 #endif
666
667 return (ATI_CMPL);
668 }
669
670 /*
671 +--------------------------------------------------------------------+
672 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
673 | STATE : code ROUTINE : atPercentCNAP |
674 +--------------------------------------------------------------------+
675
676 PURPOSE : %CNAP command (Calling NAme Presentation)
677 */
678
679 GLOBAL T_ATI_RSLT setatPercentCNAP(char *cl, UBYTE srcId)
680 {
681 T_ATI_CNAP_MODE cnap_mode;
682
683 TRACE_FUNCTION("setatPercentCNAP()");
684
685 cnap_mode =(T_ATI_CNAP_MODE)(*cl - '0');
686
687 switch(cnap_mode)
688 {
689 case(CNAP_DISABLED):
690 case(CNAP_ENABLED):
691 ati_user_output_cfg[srcId].cnap_mode = cnap_mode;
692 cl++;
693 return (ATI_CMPL);
694
695 default:
696 cmdCmeError(CME_ERR_OpNotAllow);
697 return (ATI_FAIL);
698 }
699 }
700
701 GLOBAL T_ATI_RSLT queatPercentCNAP(char *cl, UBYTE srcId)
702 {
703 T_ACI_RETURN ret = AT_FAIL;
704
705 TRACE_FUNCTION("queatPercentCNAP()");
706
707 ret = qAT_PercentCNAP((T_ACI_CMD_SRC)srcId);
708 if( ret NEQ AT_EXCT )
709 {
710 cmdCmeError(CME_ERR_Unknown);
711 }
712 return (map_aci_2_ati_rslt(ret));
713 }
714
715
716 /*
717 +--------------------------------------------------------------------+
718 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
719 | STATE : code ROUTINE : atPercentALS |
720 +--------------------------------------------------------------------+
721
722 PURPOSE : %ALS command (select the aternate line)
723 */
724
725
726 GLOBAL T_ATI_RSLT setatPercentALS ( char *cl, UBYTE srcId )
727 {
728 T_ACI_RETURN ACI_return = AT_FAIL;
729 T_ACI_ALS_MOD ALSmode;
730
731 TRACE_FUNCTION( "setatPercentALS()" );
732
733 switch( *cl )
734 {
735 case '0':
736 ALSmode = ALS_MOD_SPEECH;
737 break;
738
739 case '1':
740 ALSmode = ALS_MOD_AUX_SPEECH;
741 break;
742
743 default:
744 cmdCmeError(CME_ERR_OpNotSupp);
745 return (map_aci_2_ati_rslt(ACI_return));
746 }
747
748 #ifdef FF_ATI_BAT
749 {
750 T_BAT_cmd_send cmd;
751 T_BAT_cmd_set_percent_als my_bat_set_percent_als;
752
753 TRACE_FUNCTION("setatPercentALS() calls bat_send() <=== as APPLICATION");
754
755 memset(&my_bat_set_percent_als, 0, sizeof(my_bat_set_percent_als));
756 cmd.ctrl_params = BAT_CMD_SET_PERCENT_ALS;
757 cmd.params.ptr_set_percent_als = &my_bat_set_percent_als;
758
759 my_bat_set_percent_als.mode = ALSmode;
760
761 bat_send(ati_bat_get_client(srcId), &cmd);
762
763 return ATI_EXCT; /* executing, because response is passed by callback function */
764 }
765 #else /* OLD FUNCTION BODY */
766
767 ACI_return = sAT_PercentALS( (T_ACI_CMD_SRC)srcId, ALSmode );
768
769 if( ACI_return EQ AT_FAIL )
770 {
771 cmdCmeError(CME_ERR_Unknown);
772 }
773 return (map_aci_2_ati_rslt(ACI_return));
774
775 #endif /* no FF_ATI_BAT*/
776 }
777
778
779 GLOBAL T_ATI_RSLT tesatPercentALS ( char *cl, UBYTE srcId )
780 {
781 char *me = "%ALS";
782 T_ACI_RETURN ACI_return = AT_FAIL ;
783 T_ACI_ALS_MOD ALSmode;
784
785 TRACE_FUNCTION( "tesatPercentALS()" );
786
787 ACI_return = tAT_PercentALS((T_ACI_CMD_SRC)srcId, &ALSmode );
788
789 if ( ACI_return EQ AT_FAIL )
790 {
791 cmdCmeError(CME_ERR_Unknown);
792 return (ATI_FAIL);
793 }
794 else if ( ACI_return EQ AT_CMPL )
795 {
796 if (ALSmode EQ ALS_MOD_NOTPRESENT)
797 {
798 cmdCmeError(CME_ERR_OpNotSupp);
799 return (ATI_FAIL);
800 }
801 if (ALSmode EQ ALS_MOD_SPEECH)
802 sprintf(g_sa,"%s: (0)", me);
803 if (ALSmode EQ ALS_MOD_AUX_SPEECH)
804 sprintf(g_sa,"%s: (1)", me);
805 if (ALSmode EQ (ALS_MOD_SPEECH | ALS_MOD_AUX_SPEECH))
806 sprintf(g_sa,"%s: (0,1)", me);
807 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
808 }
809 return (map_aci_2_ati_rslt(ACI_return));
810 }
811
812
813 GLOBAL T_ATI_RSLT queatPercentALS ( char *cl, UBYTE srcId )
814 {
815 T_ACI_RETURN ACI_return = AT_FAIL;
816 T_ACI_ALS_MOD ALSmode;
817 UBYTE ati_ALSmode;
818
819 TRACE_FUNCTION( "queatPercentALS()" );
820
821 ACI_return = qAT_PercentALS( (T_ACI_CMD_SRC)srcId, &ALSmode );
822 if( ACI_return NEQ AT_CMPL )
823 {
824 cmdCmeError(CME_ERR_Unknown);
825 return (ATI_FAIL);
826 }
827
828 switch( ALSmode )
829 {
830 case(ALS_MOD_SPEECH):
831 ati_ALSmode = 0;
832 break;
833
834 case(ALS_MOD_AUX_SPEECH):
835 ati_ALSmode = 1;
836 break;
837
838 case(ALS_MOD_NOTPRESENT):
839 default:
840 cmdCmeError(CME_ERR_OpNotSupp);
841 return (ATI_FAIL);
842 }
843
844 resp_disp(srcId, cl,"b",&ati_ALSmode);
845 return (map_aci_2_ati_rslt(ACI_return));
846 }
847
848 /*
849 +--------------------------------------------------------------------+
850 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
851 | STATE : code ROUTINE : atPercentCOLR |
852 +--------------------------------------------------------------------+
853
854 PURPOSE : %COLR command
855 no parameter.
856 */
857
858 GLOBAL T_ATI_RSLT atPercentCOLR(CHAR *cl, UBYTE srcId)
859 {
860 T_ACI_RETURN ret = AT_FAIL;
861
862 TRACE_FUNCTION("atPercentCOLR()");
863
864 if( *cl NEQ '\0'
865 AND *cl NEQ ';')
866 {
867 cmdCmeError( CME_ERR_OpNotAllow );
868 return (ATI_FAIL);
869 }
870
871 ret = qAT_PercentCOLR( (T_ACI_CMD_SRC)srcId );
872
873 if( ret NEQ AT_EXCT )
874 {
875 cmdCmeError( CME_ERR_Unknown );
876 }
877 return (map_aci_2_ati_rslt(ret));
878 }
879
880 /*
881 +--------------------------------------------------------------------+
882 | PROJECT : GSM MODULE : ATI_CMD |
883 | STATE : code ROUTINE : atPercentCUNS |
884 +--------------------------------------------------------------------+
885
886 PURPOSE : %CUNS command
887 parameters: buffering_mode.
888 0: unsolicited messages may occur any time.
889 1: unsolicited messages can't happen while typing a command.
890 2: unsolicited messages can't happen between starting typing a command
891 and its final result.
892 */
893
894 GLOBAL T_ATI_RSLT setatPercentCUNS(char *cl, UBYTE srcId)
895 {
896 SHORT buffering_mode = -1;
897 T_ATI_SRC_PARAMS *src_params;
898
899 cl = parse(cl,"d",&buffering_mode);
900
901 src_params = find_element (ati_src_list, srcId, search_ati_src_id);
902
903 if( cl EQ NULL
904 OR src_params EQ NULL
905 OR buffering_mode < 0
906 OR buffering_mode > 2)
907 {
908 cmdCmeError(CME_ERR_OpNotAllow);
909 return (ATI_FAIL);
910 }
911
912 src_params->buff_uns_mode = (T_ATI_BUFF_UNS_MODE)buffering_mode;
913 return (ATI_CMPL);
914 }
915
916 GLOBAL T_ATI_RSLT queatPercentCUNS(char *cl, UBYTE srcId)
917 {
918 UBYTE buffering_mode = ((UBYTE)-1); /* adjust is UBYTE type so typecasting -1 with UBYTE */
919 T_ATI_SRC_PARAMS *src_params;
920
921 src_params = find_element (ati_src_list, srcId, search_ati_src_id);
922 if(src_params EQ NULL)
923 {
924 cmdCmeError(CME_ERR_OpNotAllow);
925 return (ATI_FAIL);
926 }
927
928 buffering_mode = (UBYTE)src_params->buff_uns_mode;
929 resp_disp(srcId, cl, "b", &buffering_mode);
930 return (ATI_CMPL);
931 }
932
933
934 /*
935 +--------------------------------------------------------------------+
936 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
937 | STATE : code ROUTINE : atPercentPPP |
938 +--------------------------------------------------------------------+
939
940 PURPOSE : %PPP command
941 parameters: protocol, login name, password.
942 */
943 #ifdef DTI
944 #if defined(FF_WAP) || defined(FF_PPP) || defined(FF_GPF_TCPIP) || defined(FF_SAT_E)
945 GLOBAL T_ATI_RSLT atPercentPPP (CHAR *cl, UBYTE srcId)
946 {
947 T_ACI_PPP_PROT protocol;
948 T_ACI_RETURN ret = AT_FAIL;
949 CHAR buffer_login[sizeof(pppShrdPrm.ppp_login)];
950 CHAR buffer_pwd[sizeof(pppShrdPrm.ppp_password)];
951 T_ACI_PPP_CON con_type = USE_NO_PPP_FOR_AAA;
952
953 cl=parse(cl,"dssd",&protocol, sizeof(buffer_login),
954 &buffer_login,
955 sizeof(buffer_pwd),
956 &buffer_pwd,
957 &con_type);
958 if(!cl)
959 {
960 cmdCmeError(CME_ERR_OpNotAllow);
961 return (ATI_FAIL);
962 }
963
964 #ifdef FF_ATI_BAT
965 {
966 T_BAT_cmd_send cmd;
967 T_BAT_cmd_set_percent_ppp my_bat_set_percent_ppp;
968
969 TRACE_FUNCTION("atPercentPPP() calls bat_send() <=== as APPLICATION");
970
971 memset(&my_bat_set_percent_ppp,0,sizeof(T_BAT_cmd_set_percent_ppp));
972 cmd.ctrl_params = BAT_CMD_SET_PERCENT_PPP;
973 cmd.params.ptr_set_percent_ppp = &my_bat_set_percent_ppp;
974
975 my_bat_set_percent_ppp.authprot = (T_BAT_percent_ppp_authprot)protocol;
976 if(my_bat_set_percent_ppp.c_user = strlen(buffer_login))
977 {
978 my_bat_set_percent_ppp.v_user = TRUE;
979 memcpy(my_bat_set_percent_ppp.user,buffer_login,
980 my_bat_set_percent_ppp.c_user<=BAT_MAX_PPP_USER_LEN ?
981 my_bat_set_percent_ppp.c_user : BAT_MAX_PPP_USER_LEN);
982 }
983 if(my_bat_set_percent_ppp.c_password = strlen(buffer_pwd))
984 {
985 my_bat_set_percent_ppp.v_password = TRUE;
986 memcpy(my_bat_set_percent_ppp.password,buffer_pwd,
987 my_bat_set_percent_ppp.c_password<=BAT_MAX_PPP_PASSW_LEN ?
988 my_bat_set_percent_ppp.c_password : BAT_MAX_PPP_PASSW_LEN);
989 }
990 my_bat_set_percent_ppp.conn_type = (T_BAT_percent_ppp_conn_type)con_type;
991
992 bat_send(ati_bat_get_client(srcId), &cmd);
993 return ATI_EXCT; /* executing, because response is passed by callback function */
994 }
995
996 #else /* no FF_ATI_BAT */
997
998 TRACE_FUNCTION("atPercentPPP()");
999
1000 ret = sAT_PercentPPP((T_ACI_CMD_SRC)srcId,protocol,
1001 buffer_login,
1002 buffer_pwd,
1003 con_type);
1004 if (ret EQ AT_FAIL)
1005 {
1006 cmdCmeError(CME_ERR_Unknown);
1007 }
1008 return (map_aci_2_ati_rslt(ret));
1009 #endif /* FF_ATI_BAT */
1010 }
1011
1012
1013 /** Query PPP-negotiated parameters after connection setup.
1014 *
1015 */
1016 GLOBAL T_ATI_RSLT queatPercentPPP (CHAR *cl, UBYTE srcId)
1017 {
1018 ULONG ipaddr = 0 ; /* Own IP address. */
1019 ULONG dns1 = 0, dns2 = 0 ; /* Domain Name Server addresses. */
1020
1021 qAT_PercentPPP(srcId, &ipaddr, &dns1, &dns2) ;
1022
1023 /* WARNING: this is for little endian only! */
1024 #define IPADDR_BYTE(b, a) (((a) >> ((b) * 8)) & 0xff)
1025
1026 sprintf(g_sa, "%%PPP: %u.%u.%u.%u,%u.%u.%u.%u,%u.%u.%u.%u",
1027 IPADDR_BYTE(3, ipaddr),
1028 IPADDR_BYTE(2, ipaddr),
1029 IPADDR_BYTE(1, ipaddr),
1030 IPADDR_BYTE(0, ipaddr),
1031 IPADDR_BYTE(3, dns1),
1032 IPADDR_BYTE(2, dns1),
1033 IPADDR_BYTE(1, dns1),
1034 IPADDR_BYTE(0, dns1),
1035 IPADDR_BYTE(3, dns2),
1036 IPADDR_BYTE(2, dns2),
1037 IPADDR_BYTE(1, dns2),
1038 IPADDR_BYTE(0, dns2)) ;
1039 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT);
1040 return ATI_CMPL ;
1041 }
1042
1043 #endif /* (FF_WAP) || (FF_PPP) || (FF_GPF_TCPIP) || (FF_SAT_E) */
1044 #endif /* DTI */
1045
1046
1047 /*
1048 +--------------------------------------------------------------------+
1049 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1050 | STATE : code ROUTINE : atPercentWAP |
1051 +--------------------------------------------------------------------+
1052
1053 PURPOSE : %WAP command
1054 no parameters.
1055 */
1056
1057 #ifdef FF_WAP
1058 GLOBAL T_ATI_RSLT atPercentWAP (CHAR *cl, UBYTE srcId)
1059 {
1060 SHORT setwap_falg;
1061
1062 TRACE_FUNCTION("atPercentWAP()");
1063
1064 switch(*cl)
1065 {
1066 case('0'):
1067 case('1'):
1068 setwap_falg = ( (*cl - '0')? 1 : 0 );
1069 cl++;
1070 sAT_PercentWAP(srcId,setwap_falg);
1071 break;
1072
1073 default:
1074 cmdCmeError(CME_ERR_OpNotAllow);
1075 return (ATI_FAIL);
1076 }
1077
1078 return (ATI_CMPL);
1079 }
1080 #endif /* FF_WAP */
1081
1082
1083 /*
1084 +------------------------------------------------------------------------------
1085 | Function : SH - setatPercentMMITEST
1086 +------------------------------------------------------------------------------
1087 | Description : Test AT cmd for MMI
1088 | This command has been introduced in order to use the AT command interface for some MMI
1089 | specific testing. It shoudnt be compiled without MMI.
1090 |
1091 |
1092 | Parameters : char *cl
1093 | UBYTE srcId
1094 |
1095 | Return : ATI_CMPL
1096 +------------------------------------------------------------------------------
1097 */
1098
1099
1100 #if defined MFW AND defined TI_PS_FF_AT_P_CMD_MMITEST
1101
1102
1103 GLOBAL T_ATI_RSLT setatPercentMMITEST (char *cl, UBYTE srcId)
1104 {
1105 T_ACI_RETURN ret;
1106
1107 TRACE_FUNCTION("setatPercentMMITEST()");
1108
1109 if (*cl NEQ '=')
1110 {
1111 cmdCmeError (CME_ERR_OpNotAllow);
1112 return (ATI_FAIL);
1113 }
1114
1115 cl++;
1116
1117 ret = sAT_PercentMMITEST((T_ACI_CMD_SRC)srcId, cl);
1118
1119 switch(ret)
1120 {
1121 case AT_CMPL:
1122 return (ATI_CMPL);
1123
1124 case AT_FAIL:
1125 cmdCmeError(CME_ERR_Unknown);
1126 return (ATI_FAIL);
1127
1128 default:
1129 cmdCmeError(CME_ERR_Unknown);
1130 return (ATI_FAIL);
1131 } /* switch */
1132 } /* setatPercentEM */
1133 #endif /* MFW */
1134
1135 /*
1136 +-------------------------------------------------------------------------+
1137 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1138 | STATE : code ROUTINE : setatPercentSMBS |
1139 +-------------------------------------------------------------------------+
1140
1141 PURPOSE : %SMBS command (Enable presenting of both Text and PDU formats to SMBS)
1142
1143 !!!!!!!!!! ONLY FOR TEST PURPOSES !!!!!!!!!!!!!!!!!!!!!!!!!!
1144 */
1145
1146 #if defined FF_MMI_RIV
1147 GLOBAL T_ATI_RSLT setatPercentSMBS (CHAR *cl, UBYTE srcId)
1148 {
1149 T_ACI_RETURN ret = AT_FAIL;
1150 T_ACI_PERC_SMBS_MOD mode = PERC_SMBS_MOD_NotPresent;
1151
1152 TRACE_FUNCTION("setatPercentSMBS()");
1153
1154 cl=parse(cl, "d", &mode);
1155 if (cl EQ NULL)
1156 {
1157 /* parse problems */
1158 cmdCmsError(CMS_ERR_OpNotAllowed);
1159 return (ATI_FAIL);
1160 }
1161
1162 switch (mode)
1163 {
1164 case(PERC_SMBS_MOD_DISABLE):
1165 case(PERC_SMBS_MOD_ENABLE):
1166 break;
1167
1168 default:
1169 cmdCmsError(CMS_ERR_OpNotAllowed);
1170 return (ATI_FAIL);
1171 }
1172
1173 /* Parameter is allowed then set */
1174 ret = sAT_PercentSMBS (srcId, mode);
1175 if (ret EQ AT_FAIL)
1176 {
1177 cmdCmsError(CMS_ERR_UnSpecErr);
1178 return (ATI_FAIL);
1179 }
1180 return (map_aci_2_ati_rslt(ret));
1181 }
1182
1183 /* !!!!!!!!!! ONLY FOR TEST PURPOSES !!!!!!!!!!!!!!!!!!!!!!!!!! */
1184 GLOBAL T_ATI_RSLT queatPercentSMBS (CHAR *cl, UBYTE srcId)
1185 {
1186 T_ACI_RETURN ret = AT_FAIL;
1187 T_ACI_PERC_SMBS_MOD mode = PERC_SMBS_MOD_NotPresent;
1188
1189 TRACE_FUNCTION("queatPercentSMBS()");
1190
1191 ret = qAT_PercentSMBS(srcId, &mode);
1192 if (ret EQ AT_CMPL)
1193 {
1194 sprintf(g_sa,"%s%d", "%SMBS: ", mode);
1195 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
1196 return (ATI_CMPL);
1197 }
1198 cmdCmsError(CMS_ERR_NotPresent); // use aciErrDesc
1199 return (ATI_FAIL);
1200 }
1201 #endif /* FF_MMI_RIV */
1202
1203
1204
1205
1206 /*
1207 +--------------------------------------------------------------------+
1208 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1209 | STATE : code ROUTINE : atPercentDAR |
1210 +--------------------------------------------------------------------+
1211
1212 PURPOSE : %DAR command
1213 */
1214
1215
1216 /* the following is from os.h derived for the AT%DAR command */
1217 #define FIRST_ENTRY 0xff
1218 #define NEXT_ENTRY 0xfe
1219 #define OS_OK 0
1220
1221 GLOBAL T_ATI_RSLT setatPercentDAR (CHAR *cl, UBYTE srcId)
1222 {
1223 TRACE_FUNCTION("atPercentDAR()");
1224
1225 switch(*cl)
1226 {
1227 case('\0'):
1228 break;
1229 default:
1230 cmdCmeError(CME_ERR_OpNotAllow);
1231 return (ATI_FAIL);
1232
1233 /* this is only for internal testing of the %DAR command to force a crash of the stack */
1234 /*
1235 case('1'):
1236 // do an endless loop within ACI
1237 while (TRUE)
1238 ;
1239 break; // never reached
1240
1241 case('2'):
1242 // consume all memory within ACI
1243 while (TRUE)
1244 {
1245 char *a;
1246 ACI_MALLOC(a, 10);
1247 }
1248 break; // never reached
1249
1250 case('3'):
1251 // jump to 0x00000000;
1252 {
1253 void (*a)(void)=0x00000000;
1254 (*a)();
1255 }
1256 break; // never reached
1257
1258 case('4'):
1259 // overwrite all memory
1260 memset(0x00000000, 0, 0xffffffff);
1261 break; // never reached
1262
1263 case('5'):
1264 // send many messages to ACI
1265 while (TRUE)
1266 {
1267 PALLOC(mncc_alert_ind, MNCC_ALERT_IND);
1268 mncc_alert_ind->ti = 0;
1269 PSENDX(ACI, mncc_alert_ind);
1270 }
1271 break; // never reached
1272
1273 case('6'):
1274 // generate many traces
1275 {
1276 int i;
1277 char buf[]="54 68 65 20 71 75 69 63-6B 20 62 72 6F 77 6E 20 The quick brown";
1278 for (i=0; TRUE; i++)
1279 {
1280 TRACE_EVENT_P2 ("%08X %s", i, buf)
1281 }
1282 }
1283 break; // never reached
1284 */
1285
1286 }
1287 return (ATI_CMPL);
1288 }
1289
1290
1291
1292 /*
1293 GLOBAL T_ATI_RSLT queatPercentDAR (CHAR *cl, UBYTE srcId)
1294 {
1295 TRACE_FUNCTION("queatPercentDAR()");
1296 sprintf(g_sa, "Dummy");
1297 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
1298 return (ATI_CMPL);
1299 }
1300 */
1301
1302 /*
1303 +--------------------------------------------------------------------+
1304 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1305 | STATE : code ROUTINE : setatPercentCSTAT |
1306 +--------------------------------------------------------------------+
1307
1308 PURPOSE : %CSTAT command (Enable/Disable unsolicited status reports
1309 from SIM processes)
1310 */
1311
1312 GLOBAL T_ATI_RSLT setatPercentCSTAT (char* cl, UBYTE srcId)
1313 {
1314 SHORT mode = ACI_NumParmNotPresent;
1315
1316 TRACE_FUNCTION("setatPercentCSTAT()");
1317
1318 cl = parse(cl,"r",&mode);
1319 if(!cl OR mode > 1 OR mode < 0)
1320 {
1321 cmdCmeError(CME_ERR_OpNotAllow);
1322 return (ATI_FAIL);
1323 }
1324
1325 ati_user_output_cfg[srcId].CSTAT_stat=(UBYTE)mode;
1326 return (ATI_CMPL);
1327 }
1328
1329 /*
1330 +--------------------------------------------------------------------+
1331 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1332 | STATE : code ROUTINE : queatPercentCSTAT |
1333 +--------------------------------------------------------------------+
1334
1335 PURPOSE : %CSTAT command (query unsolicited status reports
1336 from SIM processes)
1337 */
1338
1339 GLOBAL T_ATI_RSLT queatPercentCSTAT (char* cl, UBYTE srcId)
1340 {
1341
1342 int value;
1343
1344 TRACE_FUNCTION("queatPercentCSTAT()");
1345
1346 value = (int)ati_user_output_cfg[srcId].CSTAT_stat;
1347 resp_disp(srcId, cl,"e",&value);
1348 return (ATI_CMPL);
1349
1350 }
1351
1352 /*
1353 +--------------------------------------------------------------------+
1354 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1355 | STATE : code ROUTINE : tesatPercentNRG |
1356 +--------------------------------------------------------------------+
1357
1358 PURPOSE : AT%NRG=? command
1359 */
1360 GLOBAL T_ATI_RSLT tesatPercentNRG (char *cl, UBYTE srcId)
1361 {
1362 T_ACI_RETURN ret = AT_FAIL;
1363 CHAR *cmd_key = "%NRG:";
1364 CHAR testcmd_output[25];
1365 T_ACI_NRG NRG_options;
1366
1367 TRACE_FUNCTION("tesatPercentNRG()");
1368
1369 ret = tAT_PercentNRG((T_ACI_CMD_SRC)srcId, &NRG_options);
1370
1371 if(ret EQ AT_CMPL)
1372 {
1373 if(NRG_options.reg_mode)
1374 {
1375 strcpy(testcmd_output, "(");
1376 if(NRG_options.reg_mode & NRG_REG_Auto)
1377 {
1378 strcat(testcmd_output, "0");
1379 }
1380 if(NRG_options.reg_mode & NRG_REG_Manual)
1381 {
1382 strcat(testcmd_output, ",1");
1383 }
1384 if(NRG_options.reg_mode & NRG_REG_Both)
1385 {
1386 strcat(testcmd_output, ",4");
1387 }
1388 strcat(testcmd_output, ")");
1389 }
1390
1391 if(NRG_options.srv_mode)
1392 {
1393 if(NRG_options.srv_mode EQ (NRG_SRV_Full | NRG_SRV_Limited | NRG_SRV_NoSrv | NRG_SRV_SetRegModeOnly))
1394 {
1395 strcat(testcmd_output, ",(0-3)");
1396 }
1397 else
1398 {
1399 strcat(testcmd_output, ",(");
1400 if(NRG_options.srv_mode & NRG_SRV_Full)
1401 {
1402 strcat(testcmd_output, "0");
1403 }
1404 if(NRG_options.srv_mode & NRG_SRV_Limited)
1405 {
1406 strcat(testcmd_output, ",1");
1407 }
1408 if(NRG_options.srv_mode & NRG_SRV_NoSrv)
1409 {
1410 strcat(testcmd_output, ",2");
1411 }
1412 if(NRG_options.srv_mode & NRG_SRV_SetRegModeOnly)
1413 {
1414 strcat(testcmd_output, ",3");
1415 }
1416 strcat(testcmd_output, ")");
1417 }
1418
1419 }
1420
1421 if(NRG_options.opr_frmt)
1422 {
1423 if(NRG_options.opr_frmt EQ (NRG_OPR_Long | NRG_OPR_Short | NRG_OPR_Numeric))
1424 {
1425 strcat(testcmd_output, ",(0-2)");
1426 }
1427 else
1428 {
1429 strcat(testcmd_output, ",(");
1430 if(NRG_options.opr_frmt & NRG_OPR_Long)
1431 {
1432 strcat(testcmd_output, "0");
1433 }
1434 if(NRG_options.opr_frmt & NRG_OPR_Short)
1435 {
1436 strcat(testcmd_output, ",1");
1437 }
1438 if(NRG_options.opr_frmt & NRG_OPR_Numeric)
1439 {
1440 strcat(testcmd_output, ",2");
1441 }
1442 strcat(testcmd_output, ")");
1443 }
1444
1445 }
1446 sprintf(g_sa,"%s %s",cmd_key, testcmd_output);
1447 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT);
1448 return(ATI_CMPL);
1449 }
1450 return(map_aci_2_ati_rslt(ret));
1451 }
1452
1453 #ifdef TI_PS_FF_AT_P_CMD_CUSCFG
1454 /*
1455 +--------------------------------------------------------------------+
1456 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1457 | STATE : code ROUTINE : setatPercentCSTAT |
1458 +--------------------------------------------------------------------+
1459
1460 PURPOSE : %CUSCFG command (Enable/Disable customized handling of facilities specified)
1461 */
1462
1463 GLOBAL T_ATI_RSLT setatPercentCUSCFG (char* cl, UBYTE srcId)
1464 {
1465 #ifdef _SIMULATION_
1466 T_ACI_RETURN ret = AT_FAIL;
1467 T_ACI_CUSCFG_FAC fac_num = CUSCFG_FAC_Not_Present;
1468 T_ACI_CUSCFG_MOD mode;
1469 T_ACI_CUSCFG_STAT status;
1470 char fac_str[MAX_FAC_STR_LENGTH] = {0};
1471 char value[MAX_VALUE_LENGTH] = {0};
1472 USHORT i;
1473 SHORT pos;
1474 #endif /* _SIMULATION_ */
1475
1476 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1477
1478 TRACE_FUNCTION("setatPercentCUSCFG()");
1479
1480 /*
1481 * The command being added for a customer should be blocked from other users
1482 * shall be used only for Windows simulation
1483 */
1484 #ifdef _SIMULATION_
1485
1486 cl = parse(cl,"sds",(LONG)MAX_FAC_STR_LENGTH,fac_str, &mode, (LONG)MAX_VALUE_LENGTH, value);
1487
1488 if(!cl OR *fac_str EQ 0 OR mode < 0 OR mode >2)
1489 {
1490 cmdCmeError(CME_ERR_OpNotAllow);
1491 return (ATI_FAIL);
1492 }
1493
1494 strcpy(fac_str, strupper(fac_str));
1495 for (i=0;cus_fac[i].name NEQ NULL; i++)
1496 {
1497 if (strcmp(cus_fac[i].name,fac_str) EQ 0 )
1498 {
1499 fac_num=cus_fac[i].fac; /*translates facility string in facility number */
1500 break;
1501 }
1502 }
1503
1504 if(fac_num EQ CUSCFG_FAC_Not_Present)
1505 {
1506 cmdCmeError(CME_ERR_OpNotAllow);
1507 return (ATI_FAIL);
1508 }
1509
1510 if(mode EQ CUSCFG_MOD_Query)
1511 {
1512 ret = qAT_PercentCUSCFG(srcId, fac_num, &status);
1513 if(ret EQ AT_CMPL)
1514 {
1515 pos = sprintf(g_sa,"%s: %d", "%CUSCFG", status);
1516
1517 ci_remTrailCom(g_sa, pos);
1518 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
1519 return (ATI_CMPL);
1520 }
1521
1522 }
1523 else
1524 {
1525 ret = sAT_PercentCUSCFG(srcId, fac_num, mode, value);
1526 }
1527
1528 if(ret NEQ AT_CMPL)
1529 {
1530 cmdCmeError(CME_ERR_Unknown);
1531 }
1532
1533 return (map_aci_2_ati_rslt(ret));
1534
1535 #else
1536 cmdCmeError(CME_ERR_OpNotAllow);
1537 return (ATI_FAIL);
1538 #endif
1539
1540 }
1541 #endif /* TI_PS_FF_AT_P_CMD_CUSCFG */
1542
1543 #ifdef TI_PS_FF_AT_P_CMD_STDR
1544 /*
1545 +--------------------------------------------------------------------+
1546 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1547 | STATE : code ROUTINE : setatPercentSTDR |
1548 +--------------------------------------------------------------------+
1549
1550 PURPOSE : %STDR Read variable <std>
1551 */
1552
1553 GLOBAL T_ATI_RSLT setatPercentSTDR (CHAR *cl, UBYTE srcId)
1554 {
1555 T_ACI_RETURN ret = AT_FAIL;
1556 UBYTE rvstd;
1557
1558 TRACE_FUNCTION("setatPercentSTDR()");
1559
1560 switch (*cl)
1561 {
1562 case('\0'):
1563 /*
1564 * AT%STDR queries the value of <std> variable
1565 */
1566 ret = qAT_PercentSTDR ((T_ACI_CMD_SRC)srcId, &rvstd);
1567 if( ret NEQ AT_CMPL )
1568 {
1569 cmdCmeError(CME_ERR_Unknown);
1570 return (ATI_FAIL);
1571 }
1572 resp_disp(srcId, cl,"b",&rvstd);
1573 break;
1574
1575 default:
1576 cmdCmeError(CME_ERR_OpNotAllow);
1577 return (ATI_FAIL);
1578 }
1579 return (map_aci_2_ati_rslt(ret));
1580 }
1581 #endif /* TI_PS_FF_AT_P_CMD_STDR */
1582
1583 /*
1584 +--------------------------------------------------------------------+
1585 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1586 | STATE : code ROUTINE : setatPercentCMGMDU |
1587 +--------------------------------------------------------------------+
1588
1589 PURPOSE : %CMGMDU Reset the TP-Reply path
1590 */
1591
1592 GLOBAL T_ATI_RSLT setatPercentCMGMDU (CHAR *cl, UBYTE srcId)
1593 {
1594 T_ACI_RETURN ret = AT_FAIL;
1595 SHORT idx=-1;
1596 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1597
1598 TRACE_FUNCTION("setatPercentCMGMDU()");
1599
1600 cl = parse(cl,"r",&idx);
1601 if ( !cl OR idx > 255 OR idx < 0)
1602 {
1603 cmdCmsError(CMS_ERR_OpNotAllowed);
1604 return (ATI_FAIL);
1605 }
1606 #ifdef _CONC_TESTING_
1607 ret = sAT_PercentCMGMDU (srcId, (UBYTE)idx);
1608 #else
1609 ret = sAT_PercentCMGMDU_Gl((T_ACI_CMD_SRC)srcId, (UBYTE)idx, NULL);
1610 #endif
1611
1612 if (ret EQ AT_EXCT)
1613 {
1614 src_params->curAtCmd = AT_CMD_P_CMGMDU;
1615 return (ATI_EXCT);
1616 }
1617 else
1618 {
1619 cmdCmsError(CMS_ERR_NotPresent);
1620 return (ATI_FAIL);
1621 }
1622 }
1623
1624 #ifdef TI_PS_FF_AT_P_CMD_CTREG
1625 /*
1626 +--------------------------------------------------------------------+
1627 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1628 | STATE : code ROUTINE : setatPercentCTREG |
1629 +--------------------------------------------------------------------+
1630
1631 PURPOSE : %CTREG Sets or Reads the any one of the two tables
1632 present in the Common shared location.
1633 present in the RR enity. Usage of %CTREG command is limited
1634 and cannot be used during loc update. The best time to update
1635 is before +CFUN=1.
1636 */
1637
1638 GLOBAL T_ATI_RSLT setatPercentCTREG (CHAR *cl, UBYTE srcId)
1639 {
1640 UBYTE table[MAX_CTREG_TAB_LEN*2 + 1];
1641 USHORT tab_len = 0;
1642 UBYTE i = 0;
1643 T_ACI_RETURN ret = AT_FAIL;
1644 T_TREG treg;
1645 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1646
1647 /* initialize the local varibles */
1648 memset(table,NOT_PRESENT_8BIT,sizeof(table));
1649
1650 TRACE_FUNCTION("setatPercentCTREG()");
1651
1652 cl = parse(cl,"dds",&treg.mode,&treg.tab_id,sizeof(table),table);
1653
1654 /*
1655 * no mode & tab_id values are allowed other than 1-2
1656 */
1657 if( !cl OR (treg.mode < TREG_READ_MODE OR treg.mode > TREG_WRITE_MODE)
1658 OR (treg.tab_id < NOSERVICE_MODE_TIME OR treg.tab_id > LIMSERVICE_MODE_TIME))
1659 {
1660 cmdCmeError(CME_ERR_OpNotAllow);
1661 return (ATI_FAIL);
1662 }
1663
1664 if(treg.mode EQ TREG_READ_MODE)
1665 {
1666 /*
1667 * If User gives Table values in read mode then Error is send to the terminal.
1668 */
1669 if(*table NEQ NOT_PRESENT_8BIT)
1670 {
1671 cmdCmeError (CME_ERR_OpNotAllow);
1672 return ATI_FAIL;
1673 }
1674
1675 ret = qAT_PercentCTREG ((T_ACI_CMD_SRC)srcId,&treg);
1676
1677 i=sprintf(g_sa,"%s: %d, %d, \"","%CTREG",treg.mode, treg.tab_id);
1678 utl_binToHex(treg.tab_val,MAX_CTREG_TAB_LEN,g_sa+i);
1679 sprintf(g_sa+strlen(g_sa),"\"");
1680
1681 if(ret EQ AT_CMPL)
1682 {
1683 io_sendMessageEx(srcId, g_sa, ATI_NORMAL_OUTPUT);
1684 }
1685 else
1686 {
1687 cmdCmeError (CME_ERR_Unknown);
1688 }
1689 }
1690 else
1691 {
1692 tab_len = utl_HexStrToBin((UBYTE*)table, (MAX_CTREG_TAB_LEN*2),
1693 treg.tab_val, MAX_CTREG_TAB_LEN);
1694
1695 if(tab_len NEQ MAX_CTREG_TAB_LEN)
1696 {
1697 cmdCmeError(CME_ERR_OpNotAllow);
1698 return ATI_FAIL;
1699 }
1700
1701 ret = sAT_PercentCTREG((T_ACI_CMD_SRC)srcId,&treg);
1702
1703 if (ret NEQ AT_CMPL)
1704 {
1705 cmdCmeError (CME_ERR_Unknown);
1706 }
1707 }
1708 return (map_aci_2_ati_rslt(ret));
1709 }
1710 #endif /* TI_PS_FF_AT_P_CMD_CTREG */
1711
1712 #endif /* ATI_CSC_C */