FreeCalypso > hg > freecalypso-citrine
comparison g23m-aci/aci/ati_csc.c @ 0:75a11d740a02
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",®Mode,&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,®Mode,&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 */ |