FreeCalypso > hg > fc-tourmaline
comparison src/g23m-aci/aci/ati_bas.c @ 1:fa8dc04885d8
src/g23m-*: import from Magnetite
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Fri, 16 Oct 2020 06:25:50 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
0:4e78acac3d88 | 1:fa8dc04885d8 |
---|---|
1 /* | |
2 +----------------------------------------------------------------------------- | |
3 | Project : GSM-F&D (8411) | |
4 | Modul : ATI | |
5 +----------------------------------------------------------------------------- | |
6 | Copyright 2002 Texas Instruments Berlin, AG | |
7 | All rights reserved. | |
8 | | |
9 | This file is confidential and a trade secret of Texas | |
10 | Instruments Berlin, AG | |
11 | The receipt of or possession of this file does not convey | |
12 | any rights to reproduce or disclose its contents or to | |
13 | manufacture, use, or sell anything it may describe, in | |
14 | whole, or in part, without the specific written consent of | |
15 | Texas Instruments Berlin, AG. | |
16 +----------------------------------------------------------------------------- | |
17 | Purpose : AT Command Interpreter: basic functions. | |
18 +----------------------------------------------------------------------------- | |
19 */ | |
20 | |
21 #ifndef ATI_BAS_C | |
22 #define ATI_BAS_C | |
23 | |
24 #include "aci_all.h" | |
25 | |
26 #include <ctype.h> | |
27 #include <string.h> | |
28 | |
29 #include "aci_cmh.h" | |
30 #include "ati_cmd.h" | |
31 #include "aci_cmd.h" | |
32 #include "aci_io.h" | |
33 #include "aci_cmd.h" | |
34 #include "l4_tim.h" | |
35 #include "line_edit.h" | |
36 #include "aci_lst.h" | |
37 | |
38 #include "pcm.h" | |
39 #include "audio.h" | |
40 #include "aci.h" | |
41 #include "rx.h" | |
42 #include "pwr.h" | |
43 #include "l4_tim.h" | |
44 | |
45 | |
46 #ifdef GPRS | |
47 #ifdef DTI | |
48 #include "dti.h" | |
49 #include "dti_conn_mng.h" | |
50 #include "dti_cntrl_mng.h" | |
51 #endif /* DTI */ | |
52 #include "gaci.h" | |
53 #include "gaci_cmh.h" | |
54 #include "gaci_cmd.h" | |
55 #endif /* GPRS */ | |
56 | |
57 #include "aci_mem.h" | |
58 #include "aci_prs.h" | |
59 | |
60 #include "ati_int.h" | |
61 | |
62 #ifndef _SIMULATION_ | |
63 #include "ffs/ffs.h" | |
64 #endif | |
65 | |
66 #ifdef FF_ATI_BAT | |
67 | |
68 #include "typedefs.h" | |
69 #include "gdd.h" | |
70 #include "bat.h" | |
71 | |
72 #include "ati_bat.h" | |
73 | |
74 #endif /*FF_ATI_BAT*/ | |
75 | |
76 #include "cl_imei.h" | |
77 #include "ksd.h" | |
78 #include "cmh_ss.h" | |
79 | |
80 #include "fc-target.h" | |
81 #include "rv/rv_defined_swe.h" // for RVM_FCHG_SWE | |
82 #include "fchg/fchg_api.h" | |
83 | |
84 LOCAL T_ATI_RSLT aciPrcsPlusCG (UBYTE srcId, CHAR* cl, CHAR* ef); | |
85 LOCAL T_ATI_RSLT setaciPrcsVolLevel ( CHAR* cl, UBYTE device ); | |
86 LOCAL T_ATI_RSLT tesaciPrcsVolLevel ( UBYTE srcId, CHAR* cl, UBYTE device ); | |
87 LOCAL T_ATI_RSLT queaciPrcsVolLevel ( UBYTE srcId, CHAR* cl, UBYTE device ); | |
88 | |
89 EXTERN T_ATI_RSLT setatPlusCLIP (char *cl, UBYTE srcId); | |
90 EXTERN T_ATI_RSLT setatPlusCOLP (char *cl, UBYTE srcId); | |
91 EXTERN T_ATI_RSLT setatPlusCREG (char *cl, UBYTE srcId); | |
92 EXTERN T_ATI_RSLT setatPercentCREG (char *cl, UBYTE srcId); | |
93 EXTERN T_ATI_RSLT setatPlusCGREG (char *cl, UBYTE srcId); | |
94 EXTERN T_ATI_RSLT setatPercentCGREG (char *cl, UBYTE srcId); | |
95 EXTERN T_ATI_RSLT setatPlusCCLK (char *cl, UBYTE srcId); | |
96 EXTERN T_ATI_RSLT queatPlusCCLK (char *cl, UBYTE srcId); | |
97 | |
98 /* for atAndF */ | |
99 EXTERN void ati_cmd_reset(UBYTE srcId); | |
100 | |
101 | |
102 GLOBAL const T_ACI_AT_CMD atw_cmd_list [] = {AT_CMD_CGREG, AT_CMD_CLIP, AT_CMD_CLIR, | |
103 AT_CMD_COLP, AT_CMD_CREG, AT_CMD_ALS, AT_CMD_CGAATT, | |
104 AT_CMD_P_CGREG, AT_CMD_CPI, AT_CMD_P_CREG, AT_CMD_NONE}; | |
105 | |
106 | |
107 #define MAX_IDX_LTH (10) | |
108 | |
109 #define MAX_ATW_STORED_PROFILE 2 /*profile number for AT&W*/ | |
110 #define MAX_ATW_CMD_NAM_LEN 15 /*Max command name length in bytes, e.g. %CGAATT;*/ | |
111 #define MAX_ONE_ATW_PRO_LEN 50 /*Max profile length of 1 command in bytes,so far %CGAATT has the longest */ | |
112 /* profile length \CmdId\Total Len\token\1st Para length\1st para\token\2nd para length\2nd para\'\0'\ */ | |
113 #define STRING 1 /*Token: string*/ | |
114 #define SIGNED_VALUE 2 /*Token: signed value*/ | |
115 #define UNSIGNED_VALUE 3 /*Token: unsigned value*/ | |
116 #define MAX_ATW_CHOSEN_CMD_NB (sizeof(atw_cmd_list)/sizeof(T_ACI_AT_CMD) -1) | |
117 /*Max number of AT commands can be chosen by user, -1 because the last entry is only an ending symbol*/ | |
118 | |
119 | |
120 /* for profile handling ATZ and AT&W */ | |
121 #ifdef _SIMULATION_ | |
122 LOCAL CHAR atw_cmd_list_simu [(MAX_ATW_CMD_NAM_LEN) *( MAX_ATW_CHOSEN_CMD_NB) + 1] = {'\0'}; | |
123 LOCAL UBYTE atw_profile_simu [MAX_ATW_STORED_PROFILE][(MAX_ATW_CHOSEN_CMD_NB) * (MAX_ONE_ATW_PRO_LEN)+1]={{'\0'},{'\0'}}; | |
124 /* simulates the profile arrays for windows test*/ | |
125 #endif | |
126 static UBYTE ATZprofile; | |
127 | |
128 GLOBAL const DBG_Memory dbg_mem_names[] = | |
129 { | |
130 {"PRI", P_DBGINFO_PrimPoolPartition}, | |
131 {"MEM", P_DBGINFO_DmemPoolPartition}, | |
132 {"DAT", P_DBGINFO_DataPoolPartition}, | |
133 { 0, P_DBGINFO_NotPresent } | |
134 }; | |
135 | |
136 /* | |
137 +--------------------------------------------------------------------+ | |
138 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
139 | STATE : code ROUTINE : atBW | | |
140 +--------------------------------------------------------------------+ | |
141 | |
142 PURPOSE : B command (only implemented to maintain compability) | |
143 W command (only implemented to maintain compability) | |
144 */ | |
145 | |
146 GLOBAL T_ATI_RSLT atBW(char *cl, UBYTE srcId) | |
147 { | |
148 SHORT i=0; | |
149 TRACE_FUNCTION("atB()"); | |
150 | |
151 while (*cl >= '0' AND *cl <= '9') | |
152 { | |
153 cl++; | |
154 i++; | |
155 if (i > 1) | |
156 { | |
157 cmdAtError(atError); | |
158 return ATI_FAIL; | |
159 } | |
160 } | |
161 return ATI_CMPL; | |
162 } | |
163 | |
164 | |
165 | |
166 /* | |
167 +--------------------------------------------------------------------+ | |
168 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
169 | STATE : code ROUTINE : atE | | |
170 +--------------------------------------------------------------------+ | |
171 | |
172 PURPOSE : E command (command echo setting) | |
173 F command (data echo setting) | |
174 L command (Speaker Volume) | |
175 M command (Speaker Mode) | |
176 Q command (result code supression) | |
177 V command (verbose response setting) | |
178 X command (Busy/Dial tone indication) | |
179 */ | |
180 | |
181 GLOBAL T_ATI_RSLT atEFLMQVX(char *cl, UBYTE srcId) | |
182 { | |
183 char *end = NULL; | |
184 UBYTE value = 0; | |
185 CHAR letter = *(cl - 1); | |
186 T_LEDIT line = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; /* init with values which say: do not change */ | |
187 /* S3 S4 S5 atE smsEnd */ | |
188 TRACE_FUNCTION("atEFLMQVX()"); | |
189 | |
190 TRACE_EVENT_P1 ("letter = %02X", letter); | |
191 | |
192 value = (UBYTE)strtol(cl, &end, 10); | |
193 if(*end ) | |
194 { | |
195 cmdAtError(atError); | |
196 return ATI_FAIL; | |
197 } | |
198 | |
199 switch(letter) | |
200 { | |
201 case('E'): | |
202 if (value > 1) | |
203 { | |
204 cmdAtError(atError); | |
205 return ATI_FAIL; | |
206 } | |
207 ati_user_output_cfg[srcId].atE = value; | |
208 /* | |
209 * line edit need this piece of information, as well | |
210 */ | |
211 line.atE = ati_user_output_cfg[srcId].atE; | |
212 ledit_set_config (srcId, line); | |
213 return ATI_CMPL; /* return to prevent non used p at the end of this function */ | |
214 case('F'): | |
215 break; | |
216 case('L'): | |
217 if (value > 3) | |
218 { | |
219 cmdAtError(atError); | |
220 return ATI_FAIL; | |
221 } | |
222 at.s1415.atL = value; | |
223 break; | |
224 case('M'): | |
225 if (value > 2) | |
226 { | |
227 cmdAtError(atError); | |
228 return ATI_FAIL; | |
229 } | |
230 at.s1415.atM = value; | |
231 break; | |
232 case('Q'): | |
233 if (value > 1) | |
234 { | |
235 cmdAtError(atError); | |
236 return ATI_FAIL; | |
237 } | |
238 ati_user_output_cfg[srcId].atQ = value; | |
239 break; | |
240 case('V'): | |
241 if (value > 1) | |
242 { | |
243 cmdAtError(atError); | |
244 return ATI_FAIL; | |
245 } | |
246 at.s1415.atV = value; | |
247 break; | |
248 case('X'): | |
249 if (value > 4) | |
250 { | |
251 cmdAtError(atError); | |
252 return ATI_FAIL; | |
253 } | |
254 ati_user_output_cfg[srcId].atX = value; | |
255 break; | |
256 default: | |
257 cmdAtError(atError); | |
258 return ATI_FAIL; | |
259 } | |
260 | |
261 return ATI_CMPL; | |
262 } | |
263 | |
264 /* | |
265 +--------------------------------------------------------------------+ | |
266 | PRIJECT : GSM-F&D (8411) MIDULE : ACI_CMD | | |
267 | STATE : code RIUTINE : atI | | |
268 +--------------------------------------------------------------------+ | |
269 | |
270 PURPOSE : I command (identification) | |
271 */ | |
272 | |
273 GLOBAL T_ATI_RSLT atI(char *cl, UBYTE srcId) | |
274 { | |
275 CHAR* ef = EF_INF0_ID; | |
276 pcm_FileInfo_Type fileInfo; | |
277 USHORT value; | |
278 USHORT maxRecords; | |
279 USHORT i; | |
280 | |
281 TRACE_FUNCTION("atI()"); | |
282 | |
283 parse (cl, "r", &value); | |
284 if (!cl) | |
285 { | |
286 value = 0; | |
287 } | |
288 | |
289 /* | |
290 * The switch case here is intended for values which are reserved for | |
291 * the protocol stack manufacturer and cannot be overridden by values | |
292 * in the PCM/FFS. | |
293 */ | |
294 switch (value) | |
295 { | |
296 case 99: | |
297 io_sendMessage(srcId, "Texas Instruments", ATI_NORMAL_OUTPUT); | |
298 return ATI_CMPL; | |
299 | |
300 default: | |
301 break; | |
302 } | |
303 | |
304 if (pcm_GetFileInfo ((UBYTE*)ef, &fileInfo) NEQ DRV_OK) | |
305 { | |
306 cmdCmeError (CME_ERR_MemFail); | |
307 return ATI_FAIL; | |
308 } | |
309 | |
310 if (pcm_ReadRecord ((UBYTE*)ef, (USHORT)(value + 1), fileInfo.FileSize, | |
311 (UBYTE*)g_sa, &fileInfo.Version, &maxRecords) NEQ DRV_OK) | |
312 { | |
313 cmdCmeError (CME_ERR_MemFail); | |
314 return ATI_FAIL; | |
315 } | |
316 | |
317 i = 0; | |
318 while ((UBYTE)g_sa[i] NEQ 0xFF) | |
319 { | |
320 i++; | |
321 } | |
322 g_sa[i] = '\0'; | |
323 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT ); | |
324 | |
325 return ATI_CMPL; | |
326 } | |
327 | |
328 /* | |
329 +--------------------------------------------------------------------+ | |
330 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
331 | STATE : code ROUTINE : atTP | | |
332 +--------------------------------------------------------------------+ | |
333 | |
334 PURPOSE : TP command (select tone/pulse dialing < only implemented to | |
335 maintain compability>) | |
336 */ | |
337 | |
338 GLOBAL T_ATI_RSLT atTP(char *cl, UBYTE srcId) | |
339 { | |
340 TRACE_FUNCTION("atTP()"); | |
341 | |
342 if (*cl >= '0' AND *cl <= '9') | |
343 { | |
344 cmdAtError(atError); | |
345 return ATI_FAIL; | |
346 } | |
347 else | |
348 { | |
349 return ATI_CMPL; | |
350 } | |
351 } | |
352 | |
353 /* | |
354 +--------------------------------------------------------------------+ | |
355 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
356 | STATE : code ROUTINE : atS | | |
357 +--------------------------------------------------------------------+ | |
358 | |
359 PURPOSE : S command (S register setting) | |
360 */ | |
361 | |
362 GLOBAL T_ATI_RSLT atS(char *cl, UBYTE srcId) | |
363 { | |
364 SHORT reg_num,reg_cont,i=0; | |
365 char cont[4]; | |
366 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
367 T_LEDIT line = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; /* init with values, which say: do not change */ | |
368 T_ATI_RSLT retcd = ATI_CMPL; | |
369 | |
370 TRACE_FUNCTION("atS()"); | |
371 | |
372 reg_num=0; | |
373 while (isdigit (*cl)) | |
374 { | |
375 reg_num *= 10; | |
376 reg_num += *cl-'0'; | |
377 ++cl; | |
378 } | |
379 | |
380 switch (*cl) | |
381 { | |
382 case('?'): | |
383 { | |
384 cl++; | |
385 switch (reg_num) | |
386 { | |
387 case 0: /* supported registers for read access are listed here */ | |
388 case 1: | |
389 case 2: | |
390 case 3: | |
391 case 4: | |
392 case 5: | |
393 case 6: | |
394 case 7: | |
395 case 8: | |
396 case 10: reg_cont = at.S[reg_num]; break; /* index access register */ | |
397 case 30: reg_cont = at.S30; break; /* direct access register */ | |
398 #ifdef GPRS | |
399 case 99: reg_cont = at.S99; break; | |
400 #endif /* GPRS */ | |
401 | |
402 default: | |
403 cmdAtError(atError); | |
404 return ATI_FAIL; | |
405 } | |
406 | |
407 sprintf(g_sa,"%03d", reg_cont); | |
408 | |
409 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
410 return ATI_CMPL; | |
411 } | |
412 | |
413 case('='): | |
414 { | |
415 cl++; | |
416 if(*cl EQ '?') | |
417 { | |
418 cl++; | |
419 | |
420 switch(reg_num) | |
421 { | |
422 case(0): sprintf(g_sa,"S%d:%s",reg_num,"(0-255)"); break; | |
423 /*case(1):*/ /* S1 register is read only !!! */ | |
424 case(2): | |
425 case(3): | |
426 case(4): | |
427 case(5): sprintf(g_sa,"S%d:%s",reg_num,"(0-127)"); break; | |
428 case(6): sprintf(g_sa,"S%d:%s",reg_num,"(2-10)"); break; | |
429 case(7): sprintf(g_sa,"S%d:%s",reg_num,"(1-255)"); break; | |
430 case(8): sprintf(g_sa,"S%d:%s",reg_num,"(0-255)"); break; | |
431 case(10): | |
432 case(30): sprintf(g_sa,"S%d:%s",reg_num,"(1-254)"); break; | |
433 #ifdef GPRS | |
434 case(31): sprintf(g_sa,"S%d:%s",reg_num,"(0-255)"); break; | |
435 #endif /* GPRS */ | |
436 | |
437 default: | |
438 cmdAtError(atError); | |
439 return ATI_FAIL; | |
440 } | |
441 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
442 return ATI_CMPL; | |
443 } | |
444 else | |
445 { | |
446 while (*cl >= '0' AND *cl <= '9' AND i < 3) | |
447 { | |
448 cont[i] = (*cl); | |
449 i++; | |
450 cl++; | |
451 } | |
452 if (!i) | |
453 { | |
454 cmdAtError(atError); | |
455 return ATI_FAIL; | |
456 } | |
457 cont[i]='\0'; | |
458 reg_cont=atoi(cont); | |
459 switch(reg_num) | |
460 { | |
461 case(0): | |
462 if (reg_cont<0 OR reg_cont > 255) | |
463 { | |
464 cmdAtError(atError); | |
465 return ATI_FAIL; | |
466 } | |
467 at.rngPrms.srcID_S0 = srcId; | |
468 | |
469 #if defined (GPRS) AND defined (DTI) | |
470 | |
471 /* | |
472 * Special case of implict attach to GACI when S0 is set to | |
473 * Non-zero value. GSM 7.07 version 6.4.0 10.2.2.1 | |
474 */ | |
475 if ( reg_cont > 0 ) | |
476 { | |
477 T_CGCLASS_CLASS m_class; | |
478 T_ACI_RETURN ret; | |
479 | |
480 if (AT_CMPL NEQ qAT_PlusCGCLASS((T_ACI_CMD_SRC)srcId, &m_class)) | |
481 { | |
482 cmdAtError(atError); | |
483 return ATI_FAIL; | |
484 } | |
485 /* | |
486 * no GPRS attach requested if only GSM mobile | |
487 */ | |
488 if ( CGCLASS_CLASS_CC NEQ m_class) | |
489 { | |
490 ret = sAT_PlusCGATT ( (T_ACI_CMD_SRC)srcId, CGATT_STATE_ATTACHED ); | |
491 switch (ret) | |
492 { | |
493 case (AT_CMPL): /*operation completed*/ | |
494 break; | |
495 case (AT_EXCT): | |
496 src_params->curAtCmd = AT_CMD_CGATT; | |
497 retcd = ATI_EXCT; | |
498 break; | |
499 default: | |
500 cmdAtError(atError); /*Command failed*/ | |
501 return ATI_FAIL; | |
502 } | |
503 } | |
504 } | |
505 #endif /* GPRS */ | |
506 break; | |
507 case(2): | |
508 if (reg_cont<0 OR reg_cont > 127) | |
509 { | |
510 cmdAtError(atError); | |
511 return ATI_FAIL; | |
512 } | |
513 break; | |
514 case(3): | |
515 if (reg_cont<0 OR reg_cont > 127) | |
516 { | |
517 cmdAtError(atError); | |
518 return ATI_FAIL; | |
519 } | |
520 line.S3 = (UBYTE)reg_cont; | |
521 break; | |
522 case(4): | |
523 if (reg_cont<0 OR reg_cont > 127) | |
524 { | |
525 cmdAtError(atError); | |
526 return ATI_FAIL; | |
527 } | |
528 line.S4 = (UBYTE)reg_cont; | |
529 break; | |
530 case(5): | |
531 if (reg_cont<0 OR reg_cont > 127) | |
532 { | |
533 cmdAtError(atError); | |
534 return ATI_FAIL; | |
535 } | |
536 line.S5 = (UBYTE)reg_cont; | |
537 break; | |
538 case(6): | |
539 if (reg_cont<2 OR reg_cont > 10) | |
540 { | |
541 cmdAtError(atError); | |
542 return ATI_FAIL; | |
543 } | |
544 break; | |
545 case(7): | |
546 if (reg_cont<1 OR reg_cont > 255) | |
547 { | |
548 cmdAtError(atError); | |
549 return ATI_FAIL; | |
550 } | |
551 break; | |
552 case(8): | |
553 if (reg_cont<0 OR reg_cont > 255) | |
554 { | |
555 cmdAtError(atError); | |
556 return ATI_FAIL; | |
557 } | |
558 break; | |
559 case(10): | |
560 if (reg_cont<1 OR reg_cont > 254) | |
561 { | |
562 cmdAtError(atError); | |
563 return ATI_FAIL; | |
564 } | |
565 break; | |
566 case(30): | |
567 if (reg_cont<0 OR reg_cont > 254) | |
568 { | |
569 cmdAtError(atError); | |
570 return ATI_FAIL; | |
571 } | |
572 break; | |
573 #if defined (GPRS) AND defined (DTI) | |
574 case(99): | |
575 | |
576 if (reg_cont<0 OR reg_cont > 255) | |
577 { | |
578 cmdAtError(atError); | |
579 return ATI_FAIL; | |
580 } | |
581 break; | |
582 #endif /* GPRS */ | |
583 | |
584 default: | |
585 cmdAtError(atError); | |
586 return ATI_FAIL; | |
587 } | |
588 | |
589 switch (reg_num) | |
590 { | |
591 | |
592 case 0: /* supported registers for write access are listed here */ | |
593 /*case 1: Read Only */ | |
594 case 2: | |
595 case 3: | |
596 case 4: | |
597 case 5: | |
598 case 6: | |
599 case 7: | |
600 case 8: | |
601 case 10: at.S[reg_num]=(UBYTE)reg_cont; break; | |
602 | |
603 case 30: at.S30 =(UBYTE)reg_cont; break; | |
604 #if defined (GPRS) AND defined (DTI) | |
605 case 99: at.S99 =(UBYTE)reg_cont; break; | |
606 #endif | |
607 | |
608 default: | |
609 cmdAtError(atError); | |
610 return ATI_FAIL; | |
611 } | |
612 | |
613 | |
614 /* | |
615 * line edit need this piece of information, as well | |
616 */ | |
617 ledit_set_config (srcId, line); | |
618 break; | |
619 } | |
620 } | |
621 default: | |
622 cmdAtError(atError); | |
623 return ATI_FAIL; | |
624 } | |
625 return retcd; | |
626 } | |
627 | |
628 | |
629 | |
630 /* | |
631 PURPOSE : this function stores the pre-chosen command list in FFS, but only for windows test. | |
632 */ | |
633 #ifdef _SIMULATION_ | |
634 LOCAL T_ATI_RSLT store_command_list (void) | |
635 { | |
636 char atw_cmd_list []= "+CGREG;+CLIP;+CLIR;+COLP;+CREG;%ALS;%CGAATT;%CGREG;%CPI;%CREG;"; | |
637 TRACE_FUNCTION ("store_command_list()"); | |
638 | |
639 if ( !(strcpy (atw_cmd_list_simu, atw_cmd_list))) | |
640 { | |
641 cmdCmeError(CME_ERR_Unknown); | |
642 return ( ATI_FAIL); | |
643 } | |
644 return (ATI_CMPL); | |
645 } | |
646 #endif /*_SIMULATION_*/ | |
647 | |
648 | |
649 /* | |
650 This function gets the command Id from input command name string if it is within the default listcmdList | |
651 */ | |
652 LOCAL T_ACI_AT_CMD get_command_id_in_wn_list(CHAR *command_str) | |
653 { | |
654 int i; | |
655 T_ACI_AT_CMD command = AT_CMD_NONE; | |
656 TRACE_FUNCTION ("get_command_id_in_wn_list()"); | |
657 | |
658 command = get_command_id(command_str); | |
659 for (i = 0;*(atw_cmd_list+i) NEQ AT_CMD_NONE; i ++) | |
660 { | |
661 if (command EQ *(atw_cmd_list+i) ) | |
662 { | |
663 return (command); | |
664 } | |
665 } | |
666 TRACE_EVENT_P1("AT&W: unrecognized command in the list: %s", command_str); | |
667 return (AT_CMD_NONE); | |
668 } | |
669 | |
670 /* | |
671 PURPOSE : this function reads the pre-chosen command list in FFS and then builds a string | |
672 of all the command Ids according to the command list read. | |
673 | |
674 Parameter: | |
675 cmd_id_read: To hold the list of command Ids | |
676 */ | |
677 | |
678 LOCAL T_ATI_RSLT read_command_list_from_ffs (UBYTE *cmd_id_read) | |
679 { | |
680 int i, k; | |
681 #ifndef _SIMULATION_ | |
682 int val; | |
683 #endif /*_SIMULATION_*/ | |
684 int j = 0; | |
685 CHAR *cmdList_temp;/*to hold the command name strings read from FFS*/ | |
686 CHAR string_temp [MAX_ATW_CMD_NAM_LEN] = {'\0'};/* hold 1 command name string*/ | |
687 T_ACI_AT_CMD command = AT_CMD_NONE; | |
688 | |
689 TRACE_FUNCTION ("read_command_list_from_ffs()"); | |
690 ACI_MALLOC (cmdList_temp, (MAX_ATW_CHOSEN_CMD_NB) *( MAX_ATW_CMD_NAM_LEN) + 1) ; | |
691 | |
692 #ifndef _SIMULATION_ | |
693 if ((val = ffs_fread ("/gsm/com/cmdList", cmdList_temp, | |
694 (MAX_ATW_CHOSEN_CMD_NB) *( MAX_ATW_CMD_NAM_LEN) + 1) )< 1) | |
695 { | |
696 TRACE_EVENT_P1("AT&W: Read command list from ffs fail. Returned val is %d", val); | |
697 #else /*!_SIMULATION_*/ | |
698 if (!(strcpy (cmdList_temp, atw_cmd_list_simu))) | |
699 { | |
700 TRACE_EVENT("AT&W: Read command list fail. "); | |
701 #endif /*!_SIMULATION_*/ | |
702 ACI_MFREE (cmdList_temp); | |
703 cmdCmeError(CME_ERR_Unknown); | |
704 return (ATI_FAIL); | |
705 } | |
706 | |
707 /*The for loop builds the command string and then gets the corresponding command Id*/ | |
708 for (i = 0, k = 0; *(cmdList_temp+i) NEQ '\0' AND k < (int)(MAX_ATW_CHOSEN_CMD_NB); i ++) | |
709 { | |
710 if (*(cmdList_temp+i) NEQ ';' ) | |
711 { | |
712 /* No ";" is met*/ | |
713 *(string_temp+j++) = *(cmdList_temp+i); | |
714 } | |
715 else | |
716 { | |
717 *(string_temp+j) = '\0'; | |
718 command = get_command_id_in_wn_list (string_temp); | |
719 if (command NEQ AT_CMD_NONE) /* ignore it if unknown string met*/ | |
720 { | |
721 *(cmd_id_read+k++) = (UBYTE)command; | |
722 } | |
723 j = 0; | |
724 *string_temp = '\0'; | |
725 } | |
726 } | |
727 *(cmd_id_read+k) = (UBYTE)AT_CMD_NONE; | |
728 ACI_MFREE (cmdList_temp); | |
729 return (ATI_CMPL); | |
730 } | |
731 | |
732 /* | |
733 PURPOSE : this function builds and stores the profile in FFS according to the command list read. | |
734 */ | |
735 LOCAL T_ATI_RSLT store_profile_to_ffs (T_ACI_CMD_SRC srcId, SHORT nProfile) | |
736 { | |
737 int i; | |
738 #ifndef _SIMULATION_ | |
739 int val; | |
740 #endif /*_SIMULATION_*/ | |
741 int index = 1; | |
742 int command_length = 0; | |
743 /*to hold the content of parameters*/ | |
744 #if defined (GPRS) AND defined (DTI) | |
745 T_CGAATT_ATTACH_MODE para1; | |
746 T_CGAATT_DETACH_MODE para2; | |
747 #endif /*GPRS*/ | |
748 T_ACI_ALS_MOD para3 = ALS_MOD_NOTPRESENT; | |
749 T_ACI_CLIR_MOD mode = CLIR_MOD_NotPresent; | |
750 UBYTE *profile = NULL; /*to hold the content of profile, memory will be allocated later*/ | |
751 UBYTE cmdIds [MAX_ATW_CHOSEN_CMD_NB +1] = {'\0'}; /*to hold the list of command Ids*/ | |
752 char ffsAddr[] = "/gsm/com/profilex"; /*address in ffs, the x depends on which profile to save*/ | |
753 | |
754 TRACE_FUNCTION ("store_profile_to_ffs()"); | |
755 | |
756 ffsAddr[ strlen (ffsAddr) - 1] = '0' + nProfile; | |
757 | |
758 /*before storing of profile read command list from FFS, cmdIds is used to hold the Ids of commands*/ | |
759 if ( read_command_list_from_ffs (cmdIds) NEQ ATI_CMPL) | |
760 { | |
761 cmdCmeError(CME_ERR_Unknown); | |
762 return (ATI_FAIL); | |
763 } | |
764 | |
765 /*command list is successfully read and now ready to build profile, allocate memory first*/ | |
766 ACI_MALLOC (profile, (MAX_ATW_CHOSEN_CMD_NB) * (MAX_ONE_ATW_PRO_LEN) + 1); | |
767 | |
768 /*this for_loop builds the profile*/ | |
769 for (i = 0; *(cmdIds+i) NEQ AT_CMD_NONE; i ++) | |
770 { | |
771 command_length = 5; | |
772 TRACE_EVENT_P1 ("cmd id is: %d", *(cmdIds+i)); | |
773 *(profile+index++) = *(cmdIds+i); /*stores command ID as the first element for each command*/ | |
774 | |
775 switch (*(cmdIds+i)) | |
776 { | |
777 #if defined (GPRS) AND defined (DTI) | |
778 case AT_CMD_CGREG: | |
779 *(profile+index++) = command_length;/*total length in bytes for this command*/ | |
780 *(profile+index++) = SIGNED_VALUE; /*token indicates the following parameter is signed*/ | |
781 *(profile+index++) = sizeof (UBYTE); /*length of the following parameter*/ | |
782 *(profile+index++) = (UBYTE)(ati_gprs_user_output_cfg[srcId].plus_cgreg.mod_lac_cid.pres_mode); | |
783 break; | |
784 case AT_CMD_P_CGREG: | |
785 *(profile+index++) = command_length; | |
786 *(profile+index++) = SIGNED_VALUE; | |
787 *(profile+index++) = sizeof (UBYTE); | |
788 *(profile+index++) = (UBYTE)(ati_gprs_user_output_cfg[srcId].percent_cgreg.mod_lac_cid.pres_mode); | |
789 break; | |
790 case AT_CMD_CGAATT: | |
791 qAT_PercentCGAATT(srcId, ¶1, ¶2); | |
792 command_length = 8; | |
793 *(profile+index++) = command_length; | |
794 *(profile+index++) = SIGNED_VALUE; | |
795 *(profile+index++) = sizeof (UBYTE); | |
796 *(profile+index++) = (UBYTE)para1; /*first param*/ | |
797 *(profile+index++) = SIGNED_VALUE; | |
798 *(profile+index++) = sizeof (UBYTE); | |
799 *(profile+index++) = (UBYTE)para2; /*second param*/ | |
800 break; | |
801 #endif /*GPRS*/ | |
802 case AT_CMD_CLIP: | |
803 *(profile+index++) = command_length; | |
804 *(profile+index++) = UNSIGNED_VALUE; | |
805 *(profile+index++) = sizeof (UBYTE); | |
806 *(profile+index++) = ati_user_output_cfg[srcId].CLIP_stat; | |
807 break; | |
808 case AT_CMD_CPI: | |
809 *(profile+index++) = command_length; | |
810 *(profile+index++) = UNSIGNED_VALUE; | |
811 *(profile+index++) = sizeof (UBYTE); | |
812 *(profile+index++) = ati_user_output_cfg[srcId].CPI_stat; | |
813 break; | |
814 case AT_CMD_COLP: | |
815 *(profile+index++) = command_length; | |
816 *(profile+index++) = UNSIGNED_VALUE; | |
817 *(profile+index++) = sizeof (UBYTE); | |
818 *(profile+index++) = at.flags.COLP_stat; | |
819 break; | |
820 | |
821 case AT_CMD_CLIR: | |
822 qAT_PercentCLIR (srcId, &mode); | |
823 *(profile+index++) = command_length; | |
824 *(profile+index++) = SIGNED_VALUE; | |
825 *(profile+index++) = sizeof (UBYTE); | |
826 *(profile+index++) = mode; | |
827 break; | |
828 case AT_CMD_ALS: | |
829 qAT_PercentALS (srcId, ¶3); | |
830 *(profile+index++) = command_length; | |
831 *(profile+index++) = SIGNED_VALUE; | |
832 *(profile+index++) = sizeof (UBYTE); | |
833 *(profile+index++) = (UBYTE)para3; | |
834 break; | |
835 case AT_CMD_CREG: | |
836 *(profile+index++) = command_length; | |
837 *(profile+index++) = SIGNED_VALUE; | |
838 *(profile+index++) = sizeof (UBYTE); | |
839 *(profile+index++) = (UBYTE)ati_user_output_cfg[srcId].creg.mod_lac_cid.pres_mode; | |
840 break; | |
841 case AT_CMD_P_CREG: | |
842 *(profile+index++) = command_length; | |
843 *(profile+index++) = SIGNED_VALUE; | |
844 *(profile+index++) = sizeof (UBYTE); | |
845 *(profile+index++) = (UBYTE)(ati_user_output_cfg[srcId].percent_creg.mod_lac_cid.pres_mode); | |
846 break; | |
847 | |
848 default: | |
849 TRACE_EVENT("Unknown AT command"); | |
850 ACI_MFREE (profile); | |
851 cmdCmeError(CME_ERR_Unknown); | |
852 return (ATI_FAIL); | |
853 } | |
854 } | |
855 | |
856 /*store the total length of the string in the first element, the max length of the profile should | |
857 not exceed 255, otherwise the stored structure in FFS should be redefined. Param <index> | |
858 is actually the length of the profile. | |
859 */ | |
860 if (index > 255) | |
861 { | |
862 ACI_MFREE (profile); | |
863 TRACE_EVENT("Profile size exceed 255."); | |
864 cmdCmeError(CME_ERR_Unknown); | |
865 return (ATI_FAIL); | |
866 } | |
867 profile [0] = (UBYTE)index; | |
868 | |
869 #ifndef _SIMULATION_ | |
870 if((val = ffs_fwrite(ffsAddr, profile, index ) )NEQ EFFS_OK) | |
871 { | |
872 TRACE_EVENT_P1("Write to FFS fail. Returned value is %d", val); | |
873 ACI_MFREE (profile); | |
874 cmdCmeError(CME_ERR_Unknown); | |
875 return (ATI_FAIL); | |
876 } | |
877 #endif /*!_SIMULATION_*/ | |
878 | |
879 #ifdef _SIMULATION_ | |
880 for (i = 0; i < index; i++) | |
881 { | |
882 atw_profile_simu[nProfile][i] = profile [i]; | |
883 TRACE_EVENT_P2 ("index is %d, store profile is: %d", i, atw_profile_simu[nProfile][i]); | |
884 } | |
885 #endif /*_SIMULATION_*/ | |
886 ACI_MFREE (profile); | |
887 return (ATI_CMPL); | |
888 } | |
889 | |
890 | |
891 /* | |
892 +--------------------------------------------------------------------+ | |
893 | PROJECT : MODULE : | | |
894 | STATE : code ROUTINE : ati_wn_store_params| | |
895 +--------------------------------------------------------------------+ | |
896 | |
897 PURPOSE : This function is the implementation of of AT command AT&W | |
898 which stores the profile of some prechosen commands to FFS. | |
899 */ | |
900 | |
901 LOCAL T_ATI_RSLT ati_wn_store_params ( UBYTE srcId, SHORT nProfile) | |
902 | |
903 { | |
904 TRACE_FUNCTION ("ati_wn_store_params()"); | |
905 | |
906 /*Stores pre-chosen AT commands. For windows test purpose only.*/ | |
907 #ifdef _SIMULATION_ | |
908 if (store_command_list () NEQ ATI_CMPL) | |
909 { | |
910 cmdCmeError(CME_ERR_Unknown); | |
911 return (ATI_FAIL) ; | |
912 } | |
913 #endif /*_SIMULATION_*/ | |
914 | |
915 /*Stores profile for chosen AT commands to FFS*/ | |
916 if (store_profile_to_ffs ((T_ACI_CMD_SRC)srcId, nProfile) NEQ ATI_CMPL) | |
917 { | |
918 cmdCmeError(CME_ERR_Unknown); | |
919 return (ATI_FAIL) ; | |
920 } | |
921 return (ATI_CMPL); | |
922 } | |
923 | |
924 | |
925 | |
926 /* | |
927 PURPOSE : this function reads the profile stored in FFS. | |
928 */ | |
929 | |
930 LOCAL T_ATI_RSLT read_profile_from_ffs (SHORT nProfile, UBYTE *profile_read, SHORT len_profile_read) | |
931 { | |
932 #ifndef _SIMULATION_ | |
933 int val; | |
934 #else | |
935 int i; | |
936 #endif | |
937 /*the last letter x depends on the profile to read*/ | |
938 char ffsAddr[] = "/gsm/com/profilex"; | |
939 | |
940 TRACE_FUNCTION ("read_profile_from_ffs()"); | |
941 /*build the correct address in FFS according to nProfile*/ | |
942 ffsAddr[ strlen (ffsAddr) - 1] = '0' + nProfile; | |
943 TRACE_EVENT_P1 ("Read address is: %s", ffsAddr); | |
944 | |
945 #ifndef _SIMULATION_ | |
946 if ((val = ffs_fread (ffsAddr, profile_read, len_profile_read ))< 1) | |
947 { | |
948 TRACE_EVENT_P1("Read profile from FFS fail, returned val is %d", val); | |
949 cmdCmeError(CME_ERR_Unknown); | |
950 return (ATI_FAIL); | |
951 } | |
952 #endif /*_SIMULATION_*/ | |
953 | |
954 #ifdef _SIMULATION_ | |
955 for (i = 0; i < atw_profile_simu[nProfile][0] ; i ++) | |
956 { | |
957 profile_read [i] = atw_profile_simu [nProfile][i]; | |
958 TRACE_EVENT_P2 ("index %d, profile_read is: %d ", i, profile_read [i]); | |
959 } | |
960 #endif /*_SIMULATION_*/ | |
961 return (ATI_CMPL); | |
962 } | |
963 | |
964 /* | |
965 +------------------------------------------------------------------------------+ | |
966 | PROJECT : GSM-PS (6147) MODULE : ATI_BAS | | |
967 | STATE : code ROUTINE : set_param_to_the_retrieved_value | | |
968 +------------------------------------------------------------------------------+ | |
969 | |
970 PURPOSE : this function handles command parameters. | |
971 */ | |
972 LOCAL T_ATI_RSLT set_param_to_the_retrieved_value(UBYTE srcId, UBYTE *string) | |
973 { | |
974 int para = * (string+4); /*this is for functions with input param of type int*/ | |
975 CHAR para1 = * (string+4); /*this is for functions with input param of type char*/ | |
976 T_ATI_RSLT atiRet = ATI_FAIL; | |
977 T_ACI_RETURN aciRet = AT_FAIL; | |
978 | |
979 TRACE_FUNCTION ("set_param_to_the_retrieved_value()"); | |
980 | |
981 /* string[2] is always the token and string[3] always the length. | |
982 so far we only have parameters with 1 byte length.*/ | |
983 if ( *(string+2) EQ SIGNED_VALUE AND *(string+3) EQ sizeof (UBYTE)) | |
984 { | |
985 para = ((* (string+4) > 127) ? *(string+4) -256: *(string+4)); | |
986 } | |
987 para1 = (CHAR)(para + '0'); /*Transform to the corresponding inern value of the corresponding character*/ | |
988 switch (*string) | |
989 { | |
990 case AT_CMD_CGREG: | |
991 #if defined (GPRS) AND defined (DTI) | |
992 atiRet = setatPlusCGREG ( ¶1, srcId); | |
993 #else | |
994 atiRet = ATI_CMPL; | |
995 #endif /*GPRS*/ | |
996 break; | |
997 case AT_CMD_P_CGREG: | |
998 #if defined (GPRS) AND defined (DTI) | |
999 atiRet = setatPercentCGREG (¶1, srcId); | |
1000 #else | |
1001 atiRet = ATI_CMPL; | |
1002 #endif /*GPRS*/ | |
1003 break; | |
1004 case AT_CMD_CGAATT: | |
1005 #if defined (GPRS) AND defined (DTI) | |
1006 aciRet = sAT_PercentCGAATT ((T_ACI_CMD_SRC)srcId, (T_CGAATT_ATTACH_MODE)para, | |
1007 (T_CGAATT_DETACH_MODE)((*(string+7) > 127) ? (*(string+7) - 256 ): *(string+7))); | |
1008 #else | |
1009 aciRet = AT_CMPL; | |
1010 #endif /*GPRS*/ | |
1011 break; | |
1012 | |
1013 case AT_CMD_CLIP: | |
1014 atiRet = setatPlusCLIP ( ¶1, srcId ); | |
1015 break; | |
1016 case AT_CMD_CPI: | |
1017 ati_user_output_cfg[srcId].CPI_stat = string[4]; | |
1018 atiRet = ATI_CMPL; | |
1019 break; | |
1020 case AT_CMD_COLP: | |
1021 atiRet = setatPlusCOLP (¶1, srcId); | |
1022 break; | |
1023 case AT_CMD_CLIR: | |
1024 aciRet = sAT_PlusCLIR ( (T_ACI_CMD_SRC)srcId,(T_ACI_CLIR_MOD)para); | |
1025 break; | |
1026 case AT_CMD_ALS: | |
1027 aciRet = sAT_PercentALS ((T_ACI_CMD_SRC)srcId,(T_ACI_ALS_MOD)para); | |
1028 break; | |
1029 case AT_CMD_CREG: | |
1030 atiRet = setatPlusCREG ( ¶1, srcId); | |
1031 break; | |
1032 case AT_CMD_P_CREG: | |
1033 atiRet = setatPercentCREG ( ¶1, srcId); | |
1034 break; | |
1035 default: | |
1036 break; | |
1037 } | |
1038 | |
1039 if (atiRet EQ ATI_FAIL AND aciRet EQ AT_FAIL ) | |
1040 { | |
1041 TRACE_EVENT_P1("Set function fails for command id %d.", *string); | |
1042 cmdCmeError(CME_ERR_Unknown); | |
1043 return( ATI_FAIL ); | |
1044 } | |
1045 return (ATI_CMPL); | |
1046 } | |
1047 | |
1048 /* | |
1049 +--------------------------------------------------------------------+ | |
1050 | PROJECT : GSM-PS (6147) MODULE : ATI_BAS | | |
1051 | STATE : code ROUTINE : ati_zn_retrieve_params | | |
1052 +--------------------------------------------------------------------+ | |
1053 | |
1054 PURPOSE : This is the implementation of AT command ATZn (n>0), | |
1055 which retrieve profile from FFS. | |
1056 */ | |
1057 GLOBAL void ati_zn_retrieve_params ( UBYTE srcId ) | |
1058 { | |
1059 int index = 1; | |
1060 UBYTE *profile_read = NULL; | |
1061 UBYTE *string = NULL; | |
1062 USHORT len_prof_read = 0; | |
1063 | |
1064 TRACE_FUNCTION ("ati_zn_retrieve_params()"); | |
1065 /* | |
1066 *------------------------------------------------------------------- | |
1067 * check parameter profile | |
1068 *------------------------------------------------------------------- | |
1069 */ | |
1070 if( ATZprofile < 1 OR | |
1071 ATZprofile > MAX_ATW_STORED_PROFILE ) | |
1072 { | |
1073 return; | |
1074 } | |
1075 len_prof_read = (MAX_ATW_CHOSEN_CMD_NB) * (MAX_ONE_ATW_PRO_LEN) + 1; | |
1076 TRACE_EVENT_P1 ("length of profile read is %d", len_prof_read); | |
1077 ACI_MALLOC (profile_read, len_prof_read); | |
1078 | |
1079 if (read_profile_from_ffs ((SHORT)(ATZprofile - 1), profile_read, len_prof_read) NEQ ATI_CMPL) | |
1080 { | |
1081 TRACE_EVENT ("read_profile_from_ffs() fail..."); | |
1082 ACI_MFREE (profile_read); | |
1083 return; | |
1084 } | |
1085 /*profile has no content*/ | |
1086 if (*profile_read EQ 1) | |
1087 { | |
1088 ACI_MFREE (profile_read); | |
1089 return; | |
1090 } | |
1091 do | |
1092 { | |
1093 string = profile_read + index; /*index points to the first element of a command profile, which is command id*/ | |
1094 index += *(profile_read+index +1);/*the second element in the profile is profile length for the command*/ | |
1095 if (set_param_to_the_retrieved_value (srcId, string) EQ ATI_FAIL) | |
1096 { | |
1097 ACI_MFREE (profile_read); | |
1098 return; | |
1099 } | |
1100 }while (index < *profile_read);/*the first element of the whole profile is the total length*/ | |
1101 | |
1102 ACI_MFREE (profile_read); | |
1103 return; | |
1104 } | |
1105 | |
1106 /* | |
1107 +--------------------------------------------------------------------+ | |
1108 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1109 | STATE : code ROUTINE : atAndW | | |
1110 +--------------------------------------------------------------------+ | |
1111 | |
1112 PURPOSE : &W command stores profiles to FFS | |
1113 */ | |
1114 | |
1115 GLOBAL T_ATI_RSLT atAndW (char *cl, UBYTE srcId) | |
1116 { | |
1117 long nProfile = ACI_NumParmNotPresent; | |
1118 char *end; | |
1119 | |
1120 TRACE_FUNCTION("atAndW()"); | |
1121 | |
1122 nProfile = strtol(cl, &end, 10); | |
1123 if(*end) | |
1124 { | |
1125 cmdAtError(atError); | |
1126 return ATI_FAIL; | |
1127 } | |
1128 /* | |
1129 * Normally omitted value should be assumed as zero | |
1130 * but AT&W does not support profile number zero. | |
1131 * So an omitted profile will be assumed as 1. | |
1132 */ | |
1133 if(cl EQ end) | |
1134 { | |
1135 nProfile = 1; | |
1136 } | |
1137 | |
1138 if( nProfile < 1 OR nProfile > MAX_ATW_STORED_PROFILE ) | |
1139 { | |
1140 cmdAtError(atError); | |
1141 return ATI_FAIL; | |
1142 } | |
1143 | |
1144 switch (ati_wn_store_params( srcId, (SHORT) (nProfile - 1))) | |
1145 { | |
1146 case ATI_CMPL: | |
1147 return ATI_CMPL; | |
1148 default: | |
1149 cmdAtError(atError); | |
1150 return ATI_FAIL; | |
1151 } | |
1152 } | |
1153 | |
1154 | |
1155 /* | |
1156 +--------------------------------------------------------------------+ | |
1157 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1158 | STATE : code ROUTINE : atZ | | |
1159 +--------------------------------------------------------------------+ | |
1160 | |
1161 PURPOSE : Z command (reset DCE and terminate any call in progress) | |
1162 */ | |
1163 | |
1164 GLOBAL T_ATI_RSLT atZ(char *cl, UBYTE srcId) | |
1165 { | |
1166 char *end = NULL; | |
1167 UBYTE value = (UBYTE)strtol(cl, &end, 10); | |
1168 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1169 | |
1170 TRACE_FUNCTION("atZ()"); | |
1171 | |
1172 if(*end) | |
1173 { | |
1174 cmdAtError(atError); | |
1175 return ATI_FAIL; | |
1176 } | |
1177 | |
1178 if( value > MAX_ATW_STORED_PROFILE ) | |
1179 { | |
1180 cmdAtError(atError); | |
1181 return( ATI_FAIL ); | |
1182 } | |
1183 | |
1184 ATZprofile = value; | |
1185 | |
1186 #ifdef FF_ATI_BAT | |
1187 { | |
1188 T_BAT_cmd_send cmd; | |
1189 T_BAT_no_parameter dummy; | |
1190 cmd.ctrl_params = BAT_CMD_AT_Z; | |
1191 dummy.bat_dummy = 0xFF; | |
1192 cmd.params.ptr_at_z = &dummy; | |
1193 if( at.rngPrms.isRng EQ TRUE ) | |
1194 { | |
1195 ati_stop_ring(); | |
1196 } | |
1197 src_params->curAtCmd = AT_CMD_Z; | |
1198 | |
1199 bat_send(ati_bat_get_client(srcId), &cmd); | |
1200 | |
1201 return (ATI_EXCT); /* executing, because response is passed by callback function */ | |
1202 } | |
1203 #else /* no FF_ATI_BAT */ | |
1204 | |
1205 switch(sAT_Z( (T_ACI_CMD_SRC)srcId, 0 )) | |
1206 { | |
1207 case AT_CMPL: | |
1208 return ATI_CMPL; | |
1209 case AT_EXCT: | |
1210 if( at.rngPrms.isRng EQ TRUE ) | |
1211 { | |
1212 ati_stop_ring(); | |
1213 } | |
1214 src_params->curAtCmd = AT_CMD_Z; | |
1215 return ATI_EXCT; | |
1216 default: | |
1217 cmdAtError(atError); | |
1218 return ATI_FAIL; | |
1219 } | |
1220 | |
1221 #endif /* no FF_ATI_BAT */ | |
1222 } | |
1223 | |
1224 /* | |
1225 +--------------------------------------------------------------------+ | |
1226 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1227 | STATE : code ROUTINE : atPlusCPAS | | |
1228 +--------------------------------------------------------------------+ | |
1229 | |
1230 PURPOSE : Phone activity status | |
1231 */ | |
1232 GLOBAL T_ATI_RSLT setatPlusCPAS(char *cl, UBYTE srcId) | |
1233 { | |
1234 T_ACI_CPAS_PAS pas = CPAS_PAS_NotPresent; | |
1235 T_ACI_RETURN ret = AT_FAIL; | |
1236 | |
1237 TRACE_FUNCTION("setatPlusCPAS()"); | |
1238 | |
1239 if (*cl NEQ '\0' AND *cl NEQ ';') | |
1240 { | |
1241 cmdAtError(atError); | |
1242 return ATI_FAIL; | |
1243 } | |
1244 | |
1245 #ifdef FF_ATI_BAT | |
1246 { | |
1247 T_BAT_cmd_send cmd; | |
1248 T_BAT_no_parameter my_bat_set_plus_cpas; | |
1249 | |
1250 TRACE_FUNCTION("setatPlusCPAS() calls bat_send() <=== as APPLICATION"); | |
1251 | |
1252 ret = qAT_PlusCPAS( srcId, &pas ); | |
1253 if (ret EQ AT_CMPL) | |
1254 { | |
1255 resp_disp(srcId, cl, "e", &pas); | |
1256 } | |
1257 else | |
1258 { | |
1259 cmdAtError(atError); | |
1260 return ATI_FAIL; | |
1261 } | |
1262 | |
1263 cmd.params.ptr_set_plus_cpas = &my_bat_set_plus_cpas; | |
1264 bat_send(ati_bat_get_client(srcId), &cmd); | |
1265 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
1266 } | |
1267 #else /* OLD FUNCTION BODY */ | |
1268 | |
1269 ret = qAT_PlusCPAS( (T_ACI_CMD_SRC)srcId, &pas ); | |
1270 if (ret EQ AT_CMPL) | |
1271 { | |
1272 resp_disp(srcId, cl, "e", &pas); | |
1273 return ATI_CMPL; | |
1274 } | |
1275 else | |
1276 { | |
1277 cmdAtError(atError); | |
1278 return ATI_FAIL; | |
1279 } | |
1280 | |
1281 #endif /* no FF_ATI_BAT*/ | |
1282 } | |
1283 /* | |
1284 +--------------------------------------------------------------------+ | |
1285 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1286 | STATE : code ROUTINE : atPlusCLAE | | |
1287 +--------------------------------------------------------------------+ | |
1288 | |
1289 PURPOSE : +CLAE command (Language Event) | |
1290 */ | |
1291 | |
1292 GLOBAL T_ATI_RSLT setatPlusCLAE (char *cl, UBYTE srcId) | |
1293 { | |
1294 T_ACI_RETURN ret = AT_FAIL; | |
1295 T_ACI_CLAE_MOD mode = CLAE_MOD_NotPresent; | |
1296 | |
1297 TRACE_FUNCTION("setatPLusCLAE()"); | |
1298 | |
1299 switch(*cl) | |
1300 { | |
1301 case('0'): | |
1302 mode=CLAE_MOD_Disable; | |
1303 break; | |
1304 case('1'): | |
1305 mode=CLAE_MOD_Enable; | |
1306 break; | |
1307 default: | |
1308 cmdCmeError(CME_ERR_OpNotAllow); | |
1309 return ATI_FAIL; | |
1310 } | |
1311 ret = sAT_PlusCLAE((T_ACI_CMD_SRC)srcId,mode); | |
1312 if (ret EQ AT_CMPL) | |
1313 return ATI_CMPL; | |
1314 else | |
1315 return ATI_FAIL; | |
1316 } | |
1317 | |
1318 GLOBAL T_ATI_RSLT queatPlusCLAE (char *cl, UBYTE srcId) | |
1319 { | |
1320 char *me="+CLAE: "; | |
1321 T_ACI_RETURN ret = AT_FAIL; | |
1322 T_ACI_CLAE_MOD mode=CLAE_MOD_NotPresent; | |
1323 | |
1324 TRACE_FUNCTION("queatPLusCLAE()"); | |
1325 | |
1326 ret = qAT_PlusCLAE((T_ACI_CMD_SRC)srcId,&mode); | |
1327 if(ret EQ AT_CMPL) | |
1328 { | |
1329 sprintf(g_sa,"%s%d",me,mode); | |
1330 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1331 return ATI_CMPL; | |
1332 } | |
1333 else | |
1334 { | |
1335 cmdCmeError(CME_ERR_Unknown); | |
1336 return ATI_FAIL; | |
1337 } | |
1338 } | |
1339 | |
1340 /* | |
1341 +--------------------------------------------------------------------+ | |
1342 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1343 | STATE : code ROUTINE : atAndC | | |
1344 +--------------------------------------------------------------------+ | |
1345 | |
1346 PURPOSE : &C command reset to factory default (not the final version) | |
1347 */ | |
1348 | |
1349 | |
1350 GLOBAL T_ATI_RSLT atAndC (char *cl, UBYTE srcId) | |
1351 { | |
1352 T_ACI_DCD_MOD val; | |
1353 | |
1354 TRACE_FUNCTION("atAndC()"); | |
1355 | |
1356 switch(*cl) | |
1357 { | |
1358 case '\0': | |
1359 case '0': | |
1360 val = DCD_ALWAYS_ON; | |
1361 break; | |
1362 | |
1363 case '1': | |
1364 val = DCD_DISABLE_AFTER_CALL; | |
1365 break; | |
1366 #ifdef RMV_01_06_04 | |
1367 case ('?'): | |
1368 qAT_AndC( srcId, &val ); | |
1369 sprintf(g_sa, "&C: %d", val); | |
1370 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1371 return (ATI_CMPL); | |
1372 #endif | |
1373 default: | |
1374 cmdAtError(atError); | |
1375 return(ATI_FAIL); | |
1376 } | |
1377 | |
1378 #ifdef DTI | |
1379 if (sAT_AndC( (T_ACI_CMD_SRC)srcId, val ) EQ AT_CMPL) | |
1380 { | |
1381 return (ATI_CMPL); | |
1382 } | |
1383 #endif | |
1384 cmdAtError(atError); | |
1385 return (ATI_FAIL); | |
1386 } | |
1387 | |
1388 /* | |
1389 +--------------------------------------------------------------------+ | |
1390 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1391 | STATE : code ROUTINE : atAndD | | |
1392 +--------------------------------------------------------------------+ | |
1393 | |
1394 PURPOSE : &D command to set the DTR behaviour | |
1395 */ | |
1396 | |
1397 | |
1398 GLOBAL T_ATI_RSLT atAndD (char *cl, UBYTE srcId) | |
1399 { | |
1400 UBYTE val; | |
1401 | |
1402 TRACE_FUNCTION("atAndD()"); | |
1403 | |
1404 switch(*cl) | |
1405 { | |
1406 case ('\0'): | |
1407 case ('0'): | |
1408 val = 0; | |
1409 break; | |
1410 case ('1'): | |
1411 val = 1; | |
1412 break; | |
1413 case ('2'): | |
1414 val = 2; | |
1415 break; | |
1416 #ifdef RMV_01_06_04 | |
1417 case ('?'): | |
1418 query = TRUE; | |
1419 break; | |
1420 #endif | |
1421 default: | |
1422 cmdAtError(atError); | |
1423 return ATI_FAIL; | |
1424 } | |
1425 | |
1426 #ifdef RMV_01_06_04 | |
1427 if (query) | |
1428 { | |
1429 ret=qAT_AndD (srcId, &val); | |
1430 if(ret EQ AT_CMPL) | |
1431 { | |
1432 sprintf(g_sa,"&D: %d", val); | |
1433 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1434 return ATI_CMPL; | |
1435 } | |
1436 } | |
1437 else | |
1438 #endif | |
1439 { | |
1440 #ifdef DTI | |
1441 if (sAT_AndD ( (T_ACI_CMD_SRC)srcId, val ) EQ AT_CMPL) | |
1442 { | |
1443 return ATI_CMPL; | |
1444 } | |
1445 #endif | |
1446 } | |
1447 cmdAtError(atError); | |
1448 return ATI_FAIL; | |
1449 } | |
1450 | |
1451 /* | |
1452 +--------------------------------------------------------------------+ | |
1453 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1454 | STATE : code ROUTINE : atAndF | | |
1455 +--------------------------------------------------------------------+ | |
1456 | |
1457 PURPOSE : &F command reset to factory default (not the final version) | |
1458 */ | |
1459 GLOBAL T_ATI_RSLT atAndF (char *cl, UBYTE srcId) | |
1460 { | |
1461 T_ACI_RETURN ret = AT_FAIL; | |
1462 | |
1463 TRACE_FUNCTION("atAndF()"); | |
1464 | |
1465 switch(*cl) | |
1466 { | |
1467 case '\0': | |
1468 case ('0'): | |
1469 /* default like ATZ */ | |
1470 ati_cmd_reset(srcId); | |
1471 break; | |
1472 case ('1'): | |
1473 ati_cmd_reset(srcId); | |
1474 | |
1475 /* | |
1476 * An other manufacturer specific parameter set. | |
1477 * | |
1478 * This is different from the user specific profiles (ATZ1). | |
1479 * | |
1480 */ | |
1481 at.flags.COLP_stat = 1; | |
1482 ati_user_output_cfg[srcId].CR_stat = 1; | |
1483 ati_user_output_cfg[srcId].CRC_stat = 1; | |
1484 ati_user_output_cfg[srcId].CLIP_stat = 1; | |
1485 ati_user_output_cfg[srcId].DR_stat = 1; | |
1486 | |
1487 ati_user_output_cfg[srcId].creg.mod_lac_cid.pres_mode = CREG_MOD_ON; | |
1488 | |
1489 #ifdef GPRS | |
1490 ati_gprs_user_output_cfg[srcId].plus_cgreg.mod_lac_cid.pres_mode = CREG_MOD_ON; | |
1491 ati_gprs_user_output_cfg[srcId].percent_cgreg.mod_lac_cid.pres_mode = CREG_MOD_ON; | |
1492 #endif | |
1493 break; | |
1494 default: | |
1495 cmdAtError(atError); | |
1496 return ATI_FAIL; | |
1497 } | |
1498 | |
1499 /* | |
1500 * The function sAT_AndF will be called with value 0 -> AT&F0 | |
1501 * because the different behavior of value 0 to 1 is only ATI | |
1502 * related and sAT_AndF() is only CMH-related. | |
1503 * | |
1504 * This is different from sAT_Z(). | |
1505 */ | |
1506 ret = sAT_AndF( (T_ACI_CMD_SRC)srcId, 0 ); | |
1507 if (ret EQ AT_CMPL) | |
1508 { | |
1509 return ATI_CMPL; | |
1510 } | |
1511 cmdAtError(atError); | |
1512 return ATI_FAIL; | |
1513 | |
1514 } | |
1515 | |
1516 /* | |
1517 +--------------------------------------------------------------------+ | |
1518 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1519 | STATE : code ROUTINE : atAndK | | |
1520 +--------------------------------------------------------------------+ | |
1521 | |
1522 PURPOSE : &K only for compatibility | |
1523 */ | |
1524 | |
1525 | |
1526 GLOBAL T_ATI_RSLT atAndK (char *cl, UBYTE srcId) | |
1527 { | |
1528 TRACE_FUNCTION("atAndK()"); | |
1529 | |
1530 switch(*cl) | |
1531 { | |
1532 case ('0'): | |
1533 case ('1'): | |
1534 case ('2'): | |
1535 case ('3'): | |
1536 case ('4'): | |
1537 return ATI_CMPL; | |
1538 default: | |
1539 cmdAtError(atError); | |
1540 return ATI_FAIL; | |
1541 } | |
1542 } | |
1543 | |
1544 /* | |
1545 +--------------------------------------------------------------------+ | |
1546 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1547 | STATE : code ROUTINE : atPlusCSQ | | |
1548 +--------------------------------------------------------------------+ | |
1549 | |
1550 PURPOSE : +CSQ, signal quality | |
1551 */ | |
1552 | |
1553 GLOBAL T_ATI_RSLT setatPlusCSQ ( char *cl, UBYTE srcId) | |
1554 { | |
1555 rx_Status_Type rxStat; | |
1556 UBYTE rssi; | |
1557 UBYTE ber; | |
1558 | |
1559 TRACE_FUNCTION("setatPlusCSQ()"); | |
1560 | |
1561 if ( rx_GetStatus ( &rxStat ) NEQ DRV_OK ) | |
1562 { | |
1563 cmdCmeError ( CME_ERR_Unknown ); | |
1564 return ATI_FAIL; | |
1565 } | |
1566 else | |
1567 { | |
1568 if ( rxStat.gsmLevel EQ 0xFF OR rxStat.gsmLevel EQ 0 ) | |
1569 { | |
1570 rssi = ACI_RSSI_FAULT; | |
1571 } | |
1572 else if ( rxStat.gsmLevel > 59 ) | |
1573 { | |
1574 rssi = 31; | |
1575 } | |
1576 else | |
1577 { | |
1578 rssi = ( rxStat.gsmLevel / 2 ) + 2; | |
1579 } | |
1580 | |
1581 if ( rxStat.rxQuality EQ RX_QUAL_UNAVAILABLE ) | |
1582 { | |
1583 ber = ACI_BER_FAULT; | |
1584 } | |
1585 else | |
1586 { | |
1587 ber = rxStat.rxQuality; | |
1588 } | |
1589 | |
1590 sprintf (g_sa, "+CSQ: %d,%d ", rssi, ber ); | |
1591 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1592 return ATI_CMPL; | |
1593 } | |
1594 } | |
1595 | |
1596 GLOBAL T_ATI_RSLT tesatPlusCSQ(CHAR *cl, UBYTE srcId) | |
1597 { | |
1598 TRACE_FUNCTION("tesatPLusCSQ()"); | |
1599 | |
1600 sprintf (g_sa, "+CSQ: 2-31,(%d),(%d)", ACI_RSSI_FAULT, ACI_BER_FAULT ); | |
1601 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1602 return ATI_CMPL; | |
1603 } | |
1604 | |
1605 /* | |
1606 +--------------------------------------------------------------------+ | |
1607 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1608 | STATE : code ROUTINE : atPlusCSQ | | |
1609 +--------------------------------------------------------------------+ | |
1610 | |
1611 PURPOSE : %CSQ, signal quality | |
1612 | |
1613 Shen,Chao Juni.12th.2003 | |
1614 */ | |
1615 | |
1616 GLOBAL T_ATI_RSLT setatPercentCSQ ( char *cl, UBYTE srcId) | |
1617 { | |
1618 T_ACI_CSQ_MODE CSQmode = CSQ_Disable; | |
1619 rx_Status_Type rxStat; | |
1620 | |
1621 | |
1622 TRACE_FUNCTION("setatPercentCSQ()"); | |
1623 | |
1624 if ( rx_GetStatus ( &rxStat ) NEQ DRV_OK ) | |
1625 { | |
1626 cmdCmeError ( CME_ERR_Unknown ); | |
1627 return ATI_FAIL; | |
1628 } | |
1629 else | |
1630 { | |
1631 switch( *cl ) | |
1632 { | |
1633 case '0': | |
1634 { | |
1635 CSQmode = CSQ_Disable; | |
1636 break; | |
1637 } | |
1638 | |
1639 case '1': | |
1640 { | |
1641 CSQmode = CSQ_Enable; | |
1642 break; | |
1643 } | |
1644 | |
1645 default: | |
1646 { | |
1647 cmdCmeError(CME_ERR_Unknown); | |
1648 return (ATI_FAIL); | |
1649 } | |
1650 } | |
1651 #ifdef FF_ATI_BAT | |
1652 { | |
1653 T_BAT_cmd_send cmd; | |
1654 T_BAT_cmd_set_percent_csq csq; | |
1655 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1656 | |
1657 TRACE_FUNCTION("setatPercentCSQ() calls bat_send() <=== as APPLICATION"); | |
1658 | |
1659 cmd.ctrl_params = BAT_CMD_SET_PERCENT_CSQ; | |
1660 cmd.params.ptr_set_percent_csq = &csq; | |
1661 csq.csq_mode = CSQmode; | |
1662 src_params->curAtCmd = AT_CMD_P_CSQ; | |
1663 bat_send(ati_bat_get_client(srcId), &cmd); | |
1664 | |
1665 return ATI_EXCT; | |
1666 } | |
1667 #else | |
1668 if (sAT_PercentCSQ((T_ACI_CMD_SRC)srcId,CSQmode) NEQ AT_CMPL) | |
1669 { | |
1670 TRACE_EVENT("setatPercentCSQ call sAT_PercentCSQ Error!!"); | |
1671 } | |
1672 | |
1673 sprintf (g_sa, "%s%d ", "%CSQ: ", CSQmode); | |
1674 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1675 return ATI_CMPL; | |
1676 #endif /* FF_ATI_BAT */ | |
1677 } | |
1678 } | |
1679 | |
1680 | |
1681 GLOBAL T_ATI_RSLT queatPercentCSQ(CHAR *cl, UBYTE srcId) | |
1682 { | |
1683 rx_Status_Type rxStat; | |
1684 | |
1685 TRACE_FUNCTION("queatPercentCSQ()"); | |
1686 | |
1687 #ifdef FF_PS_RSSI | |
1688 qAT_PercentCSQ((T_ACI_CMD_SRC)srcId,&rxStat.gsmLevel,&rxStat.rxQuality,&rxStat.actLevel,&rxStat.min_access_level); | |
1689 sprintf (g_sa, "%s %d, %d, %d, %d", "%CSQ: ",rxStat.gsmLevel, rxStat.rxQuality, rxStat.actLevel, rxStat.min_access_level); | |
1690 #else | |
1691 qAT_PercentCSQ((T_ACI_CMD_SRC)srcId,&rxStat.gsmLevel,&rxStat.rxQuality,&rxStat.actLevel); | |
1692 sprintf (g_sa, "%s %d, %d, %d", "%CSQ: ",rxStat.gsmLevel, rxStat.rxQuality, rxStat.actLevel); | |
1693 #endif | |
1694 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1695 | |
1696 return ATI_CMPL; | |
1697 } | |
1698 | |
1699 | |
1700 GLOBAL T_ATI_RSLT tesatPercentCSQ(CHAR *cl, UBYTE srcId) | |
1701 { | |
1702 TRACE_FUNCTION("tesatPercentCSQ()"); | |
1703 | |
1704 #ifdef FF_PS_RSSI | |
1705 sprintf (g_sa, "%s (%d), (%d), (%d), 0-4", "%CSQ: ",ACI_RSSI_FAULT, ACI_BER_FAULT, ACI_MIN_RXLEV_FAULT); | |
1706 #else | |
1707 sprintf (g_sa, "%s (%d), (%d), 0-4", "%CSQ: ",ACI_RSSI_FAULT, ACI_BER_FAULT); | |
1708 #endif | |
1709 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1710 return ATI_CMPL; | |
1711 } | |
1712 | |
1713 #ifdef TI_PS_FF_AT_P_CMD_DBGINFO | |
1714 /* | |
1715 +--------------------------------------------------------------------+ | |
1716 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1717 | STATE : code ROUTINE : atPercentDBGINFO | | |
1718 +--------------------------------------------------------------------+ | |
1719 | |
1720 PURPOSE : %DBGINFO, query free mem pool blocks. | |
1721 */ | |
1722 | |
1723 GLOBAL T_ATI_RSLT setatPercentDBGINFO ( char *cl, UBYTE srcId) | |
1724 { | |
1725 char *me = "%DBGINFO:"; | |
1726 ULONG param = 0; | |
1727 T_ACI_DBG_INFO stor = P_DBGINFO_NotPresent; | |
1728 CHAR type[4] = {0}; | |
1729 USHORT free = 0, alloc = 0, i = 0; | |
1730 | |
1731 TRACE_FUNCTION("queatPercentDBGINFO()"); | |
1732 | |
1733 cl = parse(cl,"sd",(LONG)4, type, ¶m); | |
1734 if(!cl OR *type EQ '\0') | |
1735 { | |
1736 cmdCmeError(CME_ERR_OpNotAllow); | |
1737 return (ATI_FAIL); | |
1738 } | |
1739 strupper(type); | |
1740 for(i=0;dbg_mem_names[i].name NEQ 0;i++) | |
1741 { | |
1742 if (!strcmp(dbg_mem_names[i].name, type) ) | |
1743 { | |
1744 stor = dbg_mem_names[i].stor; | |
1745 break; | |
1746 } | |
1747 } | |
1748 if((dbg_mem_names[i].name EQ 0) OR (param EQ 0)) | |
1749 { | |
1750 cmdCmeError(CME_ERR_OpNotAllow); | |
1751 return (ATI_FAIL); | |
1752 } | |
1753 if (qAT_PercentDBGINFO((T_ACI_CMD_SRC)srcId, param, (USHORT)stor, &free, &alloc) NEQ AT_CMPL) | |
1754 { | |
1755 cmdCmeError(CME_ERR_Unknown); | |
1756 return (ATI_FAIL); | |
1757 } | |
1758 sprintf(g_sa, "%s%d", me, free); | |
1759 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1760 | |
1761 return (ATI_CMPL); | |
1762 } | |
1763 #endif /* TI_PS_FF_AT_P_CMD_DBGINFO */ | |
1764 | |
1765 /* | |
1766 +--------------------------------------------------------------------+ | |
1767 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1768 | STATE : code ROUTINE : atPlusCBC | | |
1769 +--------------------------------------------------------------------+ | |
1770 | |
1771 PURPOSE : +CBC, battery charge | |
1772 */ | |
1773 #define ACI_BCS_BattPower 0 | |
1774 #define ACI_BCS_BattCnctd 1 | |
1775 #define ACI_BCS_NoBatt 2 | |
1776 #define ACI_BCS_PowerFault 3 | |
1777 | |
1778 GLOBAL T_ATI_RSLT atPlusCBC ( char *cl, UBYTE srcId ) | |
1779 { | |
1780 struct fchg_user_state fchg; | |
1781 UBYTE bcs; | |
1782 | |
1783 TRACE_FUNCTION("atPlusCBC()"); | |
1784 | |
1785 #ifdef RVM_FCHG_SWE | |
1786 if (fchg_get_current_state(&fchg) == RV_OK) | |
1787 { | |
1788 switch (fchg.chg_state) | |
1789 { | |
1790 case FCHG_STATE_CI_CHARGING: | |
1791 case FCHG_STATE_CV_CHARGING: | |
1792 bcs = ACI_BCS_BattCnctd; | |
1793 break; | |
1794 | |
1795 default: | |
1796 bcs = ACI_BCS_BattPower; | |
1797 } | |
1798 } | |
1799 else | |
1800 { | |
1801 bcs = ACI_BCS_PowerFault; | |
1802 fchg.batt_percent = 0; | |
1803 } | |
1804 #else | |
1805 bcs = ACI_BCS_NoBatt; | |
1806 fchg.batt_percent = 0; | |
1807 #endif | |
1808 | |
1809 sprintf(g_sa, "+CBC: %d,%d", bcs, fchg.batt_percent ); | |
1810 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1811 return ATI_CMPL; | |
1812 } | |
1813 | |
1814 /* | |
1815 +--------------------------------------------------------------------+ | |
1816 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1817 | STATE : code ROUTINE : atPlusCLVL | | |
1818 +--------------------------------------------------------------------+ | |
1819 | |
1820 PURPOSE : +CLVL, loudspeaker volume level | |
1821 */ | |
1822 GLOBAL T_ATI_RSLT setatPlusCLVL ( char *cl, UBYTE srcId ) | |
1823 { | |
1824 #ifdef FF_ATI_BAT | |
1825 { | |
1826 T_BAT_cmd_send cmd; | |
1827 T_BAT_cmd_set_plus_clvl my_bat_set_plus_clvl; | |
1828 SHORT vol; | |
1829 | |
1830 TRACE_FUNCTION("setatPlusCLVL() calls bat_send() <=== as APPLICATION"); | |
1831 | |
1832 cl = parse ( cl, "d", &vol ); | |
1833 | |
1834 if( !cl OR vol > 255 OR vol < 0 ) | |
1835 { | |
1836 cmdCmeError ( CME_ERR_OpNotAllow ); | |
1837 return ATI_FAIL; | |
1838 } | |
1839 | |
1840 memset(&my_bat_set_plus_clvl, 0, sizeof(my_bat_set_plus_clvl)); | |
1841 cmd.ctrl_params = BAT_CMD_SET_PLUS_CLVL; | |
1842 cmd.params.ptr_set_plus_clvl = &my_bat_set_plus_clvl; | |
1843 | |
1844 my_bat_set_plus_clvl.level = (U8)vol; | |
1845 | |
1846 bat_send(ati_bat_get_client(srcId), &cmd); | |
1847 | |
1848 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
1849 } | |
1850 #else /* OLD FUNCTION BODY */ | |
1851 | |
1852 TRACE_FUNCTION("setatPlusCLVL()"); | |
1853 | |
1854 return setaciPrcsVolLevel ( cl, AUDIO_SPEAKER ); | |
1855 | |
1856 #endif /* no FF_ATI_BAT*/ | |
1857 } | |
1858 | |
1859 GLOBAL T_ATI_RSLT tesatPlusCLVL ( char *cl, UBYTE srcId ) | |
1860 { | |
1861 TRACE_FUNCTION("tesatPlusCLVL()"); | |
1862 | |
1863 return tesaciPrcsVolLevel ( srcId, cl, AUDIO_SPEAKER ); | |
1864 } | |
1865 | |
1866 GLOBAL T_ATI_RSLT queatPlusCLVL ( char *cl, UBYTE srcId ) | |
1867 { | |
1868 TRACE_FUNCTION("queatPlusCLVL()"); | |
1869 | |
1870 return queaciPrcsVolLevel ( srcId, cl, AUDIO_SPEAKER ); | |
1871 } | |
1872 | |
1873 /* | |
1874 +--------------------------------------------------------------------+ | |
1875 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1876 | STATE : code ROUTINE : atPlusCRSL | | |
1877 +--------------------------------------------------------------------+ | |
1878 | |
1879 PURPOSE : +CRSL, ringer sound level | |
1880 */ | |
1881 GLOBAL T_ATI_RSLT setatPlusCRSL ( char *cl, UBYTE srcId ) | |
1882 { | |
1883 TRACE_FUNCTION("atPlusCRSL()"); | |
1884 | |
1885 return setaciPrcsVolLevel ( cl, AUDIO_BUZZER ); | |
1886 } | |
1887 | |
1888 GLOBAL T_ATI_RSLT tesatPlusCRSL ( char *cl, UBYTE srcId ) | |
1889 { | |
1890 TRACE_FUNCTION("tesatPlusCRSL()"); | |
1891 | |
1892 return tesaciPrcsVolLevel ( srcId, cl, AUDIO_BUZZER ); | |
1893 } | |
1894 | |
1895 GLOBAL T_ATI_RSLT queatPlusCRSL ( char *cl, UBYTE srcId ) | |
1896 { | |
1897 TRACE_FUNCTION("queatPlusCRSL()"); | |
1898 | |
1899 return queaciPrcsVolLevel ( srcId, cl, AUDIO_BUZZER ); | |
1900 } | |
1901 | |
1902 /* | |
1903 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1904 | STATE : code ROUTINE : aciPrcsVolLevel | | |
1905 | |
1906 PURPOSE : +CLVL, +CRSL loudspeaker volume level | |
1907 */ | |
1908 LOCAL T_ATI_RSLT setaciPrcsVolLevel ( CHAR* cl, UBYTE device ) | |
1909 { | |
1910 SHORT vol; | |
1911 | |
1912 cl = parse ( cl, "d", &vol ); | |
1913 | |
1914 if( !cl OR vol > 255 OR vol < 0 ) | |
1915 { | |
1916 cmdCmeError ( CME_ERR_OpNotAllow ); | |
1917 return ATI_FAIL; | |
1918 } | |
1919 else | |
1920 { | |
1921 if ( audio_SetAmplf( device, ( UBYTE ) vol ) NEQ DRV_OK ) | |
1922 { | |
1923 cmdCmeError ( CME_ERR_Unknown ); | |
1924 return ATI_FAIL; | |
1925 } | |
1926 } | |
1927 return ATI_CMPL; | |
1928 } | |
1929 | |
1930 LOCAL T_ATI_RSLT tesaciPrcsVolLevel ( UBYTE srcId, CHAR* cl, UBYTE device ) | |
1931 { | |
1932 CHAR *p_sa; | |
1933 audio_Status_Type audioStat; | |
1934 | |
1935 switch (device) | |
1936 { | |
1937 case AUDIO_SPEAKER: | |
1938 p_sa = "CLVL"; | |
1939 break; | |
1940 case AUDIO_BUZZER: | |
1941 p_sa = "CRSL"; | |
1942 break; | |
1943 default: | |
1944 cmdCmeError ( CME_ERR_Unknown ); | |
1945 return ATI_FAIL; | |
1946 } | |
1947 | |
1948 if ( audio_GetStatus ( device, &audioStat ) NEQ DRV_OK ) | |
1949 { | |
1950 cmdCmeError ( CME_ERR_Unknown ); | |
1951 return ATI_FAIL; | |
1952 } | |
1953 { | |
1954 sprintf( g_sa, "+%s: (%d-%d)", p_sa, audioStat.min_volume, audioStat.max_volume ); | |
1955 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1956 } | |
1957 return ATI_CMPL; | |
1958 } | |
1959 | |
1960 | |
1961 LOCAL T_ATI_RSLT queaciPrcsVolLevel ( UBYTE srcId, CHAR* cl, UBYTE device ) | |
1962 { | |
1963 SHORT vol; | |
1964 UBYTE drvVol; | |
1965 CHAR *p_sa; | |
1966 | |
1967 switch (device) | |
1968 { | |
1969 case AUDIO_SPEAKER: | |
1970 p_sa = "CLVL"; | |
1971 break; | |
1972 case AUDIO_BUZZER: | |
1973 p_sa = "CRSL"; | |
1974 break; | |
1975 default: | |
1976 cmdCmeError ( CME_ERR_Unknown ); | |
1977 return ATI_FAIL; | |
1978 } | |
1979 | |
1980 if ( audio_GetAmplf ( device, &drvVol ) NEQ DRV_OK ) | |
1981 { | |
1982 cmdCmeError ( CME_ERR_Unknown ); | |
1983 return ATI_FAIL; | |
1984 } | |
1985 else | |
1986 { | |
1987 vol = drvVol; | |
1988 sprintf ( g_sa, "+%s: %d", p_sa, vol ); | |
1989 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1990 } | |
1991 return ATI_CMPL; | |
1992 } | |
1993 | |
1994 /* | |
1995 +--------------------------------------------------------------------+ | |
1996 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1997 | STATE : code ROUTINE : atPlusCMUT | | |
1998 +--------------------------------------------------------------------+ | |
1999 | |
2000 PURPOSE : +CMUT, mute control | |
2001 */ | |
2002 #define ACI_MUTE_OFF 0 | |
2003 #define ACI_MUTE_ON 1 | |
2004 | |
2005 GLOBAL T_ATI_RSLT setatPlusCMUT(CHAR *cl, UBYTE srcId) | |
2006 { | |
2007 SHORT mute; | |
2008 UBYTE drvMute; | |
2009 | |
2010 cl = parse ( cl, "d", &mute ); | |
2011 | |
2012 if( !cl OR ( mute NEQ ACI_MUTE_OFF AND mute NEQ ACI_MUTE_ON ) ) | |
2013 { | |
2014 cmdCmeError ( CME_ERR_OpNotAllow ); | |
2015 return ATI_FAIL; | |
2016 } | |
2017 if ( mute EQ ACI_MUTE_OFF ) | |
2018 { | |
2019 drvMute = AUDIO_MUTING_OFF; | |
2020 } | |
2021 else | |
2022 { | |
2023 drvMute = AUDIO_MUTING_ON; | |
2024 } | |
2025 if (audio_SetMute (AUDIO_MICROPHONE, drvMute) NEQ DRV_OK) | |
2026 { | |
2027 cmdCmeError ( CME_ERR_Unknown ); | |
2028 return ATI_FAIL; | |
2029 } | |
2030 | |
2031 #ifdef FF_ATI_BAT | |
2032 { | |
2033 T_BAT_cmd_send cmd; | |
2034 T_BAT_cmd_set_plus_cmut my_bat_set_plus_cmut; | |
2035 | |
2036 TRACE_FUNCTION("setatPlusCMUT() calls bat_send() <=== as APPLICATION"); | |
2037 | |
2038 memset(&my_bat_set_plus_cmut, 0, sizeof(my_bat_set_plus_cmut)); | |
2039 cmd.ctrl_params = BAT_CMD_SET_PLUS_CMUT; | |
2040 cmd.params.ptr_set_plus_cmut = &my_bat_set_plus_cmut; | |
2041 my_bat_set_plus_cmut.n = (T_BAT_plus_cmut_n)drvMute; | |
2042 bat_send(ati_bat_get_client(srcId), &cmd); | |
2043 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
2044 } | |
2045 #else /* OLD FUNCTION BODY */ | |
2046 | |
2047 TRACE_FUNCTION("setatPLusCMUT()"); | |
2048 | |
2049 return ATI_CMPL; | |
2050 | |
2051 #endif /* no FF_ATI_BAT */ | |
2052 } | |
2053 | |
2054 GLOBAL T_ATI_RSLT tesatPlusCMUT ( char *cl, UBYTE srcId ) | |
2055 { | |
2056 TRACE_FUNCTION("tesatPlusCMUT()"); | |
2057 | |
2058 sprintf(g_sa, "+CMUT: (%d,%d)", ACI_MUTE_OFF, ACI_MUTE_ON ); | |
2059 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT); | |
2060 return ATI_CMPL; | |
2061 } | |
2062 | |
2063 GLOBAL T_ATI_RSLT queatPlusCMUT(CHAR *cl, UBYTE srcId) | |
2064 { | |
2065 SHORT mute; | |
2066 UBYTE drvMute; | |
2067 | |
2068 TRACE_FUNCTION("queatPlusCMUT()"); | |
2069 | |
2070 if ( audio_GetMute ( AUDIO_MICROPHONE, &drvMute ) NEQ DRV_OK ) | |
2071 { | |
2072 cmdCmeError ( CME_ERR_Unknown ); | |
2073 return ATI_FAIL; | |
2074 } | |
2075 else | |
2076 { | |
2077 if ( drvMute EQ AUDIO_MUTING_OFF ) | |
2078 { | |
2079 mute = ACI_MUTE_OFF; | |
2080 } | |
2081 else | |
2082 { | |
2083 mute = ACI_MUTE_ON; | |
2084 } | |
2085 | |
2086 sprintf ( g_sa, "+CMUT: %d", mute ); | |
2087 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
2088 return ATI_CMPL; | |
2089 } | |
2090 } | |
2091 | |
2092 /* | |
2093 +--------------------------------------------------------------------+ | |
2094 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2095 | STATE : code ROUTINE : atPlusCGMI | | |
2096 +--------------------------------------------------------------------+ | |
2097 | |
2098 PURPOSE : +CGMI, show name of manufacturer | |
2099 */ | |
2100 GLOBAL T_ATI_RSLT atPlusCGMI ( char *cl, UBYTE srcId ) | |
2101 { | |
2102 TRACE_FUNCTION("atPlusCGMI()"); | |
2103 | |
2104 return aciPrcsPlusCG (srcId, cl, EF_CGMI_ID); | |
2105 } | |
2106 | |
2107 /* | |
2108 +--------------------------------------------------------------------+ | |
2109 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2110 | STATE : code ROUTINE : atPlusCGMM | | |
2111 +--------------------------------------------------------------------+ | |
2112 | |
2113 PURPOSE : +CGMM, show name of prodcut | |
2114 */ | |
2115 GLOBAL T_ATI_RSLT atPlusCGMM ( char *cl, UBYTE srcId ) | |
2116 { | |
2117 TRACE_FUNCTION("atPlusCGMM()"); | |
2118 | |
2119 return aciPrcsPlusCG (srcId, cl, EF_CGMM_ID); | |
2120 } | |
2121 | |
2122 /* | |
2123 +--------------------------------------------------------------------+ | |
2124 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2125 | STATE : code ROUTINE : atPlusCGMR | | |
2126 +--------------------------------------------------------------------+ | |
2127 | |
2128 PURPOSE : +CGMR, show version of product | |
2129 */ | |
2130 GLOBAL T_ATI_RSLT atPlusCGMR ( char *cl, UBYTE srcId ) | |
2131 { | |
2132 TRACE_FUNCTION("atPlusCGMR()"); | |
2133 | |
2134 return aciPrcsPlusCG (srcId, cl, EF_CGMR_ID); | |
2135 } | |
2136 | |
2137 /* | |
2138 +--------------------------------------------------------------------+ | |
2139 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2140 | STATE : code ROUTINE : atPlusCGSN | | |
2141 +--------------------------------------------------------------------+ | |
2142 | |
2143 PURPOSE : +CGSN, show serial number | |
2144 */ | |
2145 GLOBAL T_ATI_RSLT atPlusCGSN ( char *cl, UBYTE srcId ) | |
2146 { | |
2147 int i; | |
2148 UBYTE IMEIBuf[CL_IMEI_SIZE]; /* IMEI buffer */ | |
2149 T_ACI_IMEI imei; | |
2150 | |
2151 TRACE_FUNCTION("atPlusCGSN()"); | |
2152 | |
2153 /* | |
2154 * New FreeCalypso logic: | |
2155 * | |
2156 * look for /pcm/CGSN first, using direct FFS API rather than PCM; | |
2157 * if /pcm/CGSN is present, return the string stored in there; | |
2158 * if no /pcm/CGSN, return 15-digit IMEI with computed check digit. | |
2159 */ | |
2160 | |
2161 i = ffs_file_read("/pcm/CGSN", (UBYTE *)g_sa, SIZE_EF_CGSN); | |
2162 if (i > 0) | |
2163 g_sa[i] = '\0'; | |
2164 else { | |
2165 cl_get_imeisv(CL_IMEI_SIZE, IMEIBuf, CL_IMEI_GET_STORED_IMEI); | |
2166 imei.tac1 = IMEIBuf[0]; | |
2167 imei.tac2 = IMEIBuf[1]; | |
2168 imei.tac3 = IMEIBuf[2]; | |
2169 imei.fac = IMEIBuf[3]; | |
2170 imei.snr1 = IMEIBuf[4]; | |
2171 imei.snr2 = IMEIBuf[5]; | |
2172 imei.snr3 = IMEIBuf[6]; | |
2173 imei.svn = IMEIBuf[7]; | |
2174 imei.cd = cmhSS_getCdFromImei ( &imei ); | |
2175 sprintf(g_sa, "%02x%02x%02x%02x%02x%02x%02x%d", | |
2176 imei.tac1, imei.tac2, imei.tac3, imei.fac, | |
2177 imei.snr1, imei.snr2, imei.snr3, imei.cd); | |
2178 } | |
2179 | |
2180 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT); | |
2181 | |
2182 return ATI_CMPL; | |
2183 } | |
2184 | |
2185 /* | |
2186 +--------------------------------------------------------------------+ | |
2187 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2188 | STATE : code ROUTINE : atPlusFMI | | |
2189 +--------------------------------------------------------------------+ | |
2190 | |
2191 PURPOSE : +FMI, show name of manufacturer | |
2192 */ | |
2193 GLOBAL T_ATI_RSLT atPlusFMI ( char *cl, UBYTE srcId ) | |
2194 { | |
2195 TRACE_FUNCTION("atPlusFMI()"); | |
2196 | |
2197 if ( *cl NEQ '?') | |
2198 { | |
2199 cmdCmeError ( CME_ERR_OpNotAllow ); | |
2200 return ATI_FAIL; | |
2201 } | |
2202 return aciPrcsPlusCG (srcId, cl, EF_CGMI_ID); | |
2203 } | |
2204 | |
2205 /* | |
2206 +--------------------------------------------------------------------+ | |
2207 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2208 | STATE : code ROUTINE : atPlusFMM | | |
2209 +--------------------------------------------------------------------+ | |
2210 | |
2211 PURPOSE : +FMM, show name of prodcut | |
2212 */ | |
2213 GLOBAL T_ATI_RSLT atPlusFMM ( char *cl, UBYTE srcId ) | |
2214 { | |
2215 TRACE_FUNCTION("atPlusFMM()"); | |
2216 | |
2217 if ( *cl NEQ '?') | |
2218 { | |
2219 cmdCmeError ( CME_ERR_OpNotAllow ); | |
2220 return ATI_FAIL; | |
2221 } | |
2222 return aciPrcsPlusCG (srcId, cl, EF_CGMM_ID); | |
2223 } | |
2224 | |
2225 /* | |
2226 +--------------------------------------------------------------------+ | |
2227 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2228 | STATE : code ROUTINE : atPlusFMR | | |
2229 +--------------------------------------------------------------------+ | |
2230 | |
2231 PURPOSE : +FMR, show version of product | |
2232 */ | |
2233 GLOBAL T_ATI_RSLT atPlusFMR ( char *cl, UBYTE srcId ) | |
2234 { | |
2235 TRACE_FUNCTION("atPlusFMR()"); | |
2236 | |
2237 if ( *cl NEQ '?') | |
2238 { | |
2239 cmdCmeError ( CME_ERR_OpNotAllow ); | |
2240 return ATI_FAIL; | |
2241 } | |
2242 return aciPrcsPlusCG (srcId, cl, EF_CGMR_ID); | |
2243 } | |
2244 | |
2245 /* | |
2246 +--------------------------------------------------------------------+ | |
2247 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2248 | STATE : code ROUTINE : aciPrcsPlusCG | | |
2249 +--------------------------------------------------------------------+ | |
2250 | |
2251 PURPOSE : | |
2252 */ | |
2253 LOCAL T_ATI_RSLT aciPrcsPlusCG (UBYTE srcId, CHAR* cl, CHAR* ef) | |
2254 { | |
2255 pcm_FileInfo_Type fileInfo; | |
2256 USHORT i; | |
2257 char *cp; | |
2258 | |
2259 TRACE_FUNCTION("aciPrcsPlusCG()"); | |
2260 | |
2261 if (pcm_GetFileInfo ((UBYTE* )ef, &fileInfo) NEQ DRV_OK) | |
2262 { | |
2263 cmdCmeError (CME_ERR_MemFail); | |
2264 return ATI_FAIL; | |
2265 } | |
2266 | |
2267 if (pcm_ReadFile ((UBYTE*)ef, fileInfo.FileSize, | |
2268 (UBYTE*)g_sa, &fileInfo.Version) NEQ DRV_OK) | |
2269 { | |
2270 cmdCmeError (CME_ERR_MemFail); | |
2271 return ATI_FAIL; | |
2272 } | |
2273 | |
2274 i = 0; | |
2275 while ((UBYTE)g_sa[i] NEQ 0xFF AND i < fileInfo.FileSize) | |
2276 i++; | |
2277 g_sa[i] = '\0'; | |
2278 | |
2279 #ifdef CONFIG_MOKOFFS | |
2280 /* | |
2281 * Openmoko's FFS has a /pcm/CGMR file programmed like this: | |
2282 * | |
2283 * GTA02BV4/Moko5 | |
2284 * | |
2285 * When queried for +CGMR, we would like to report the hardware revision | |
2286 * from FFS, but also tell the user that we are FreeCalypso and not Moko5. | |
2287 * Hence the following hack. | |
2288 */ | |
2289 if ((cp = strchr(g_sa, '/')) && !strncmp(cp + 1, "Moko", 4)) | |
2290 strcpy(cp + 1, "FreeCalypso"); | |
2291 #endif | |
2292 | |
2293 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT ); | |
2294 | |
2295 return ATI_CMPL; | |
2296 } | |
2297 | |
2298 | |
2299 /* | |
2300 +--------------------------------------------------------------------+ | |
2301 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2302 | STATE : code ROUTINE : atPlusCSCS | | |
2303 +--------------------------------------------------------------------+ | |
2304 | |
2305 PURPOSE : +CSCS command (Select TE character set) | |
2306 */ | |
2307 GLOBAL T_ATI_RSLT setatPlusCSCS (char *cl, UBYTE srcId) | |
2308 { | |
2309 CHAR txtChset[10]; | |
2310 T_ACI_CSCS_CHSET chset = CSCS_CHSET_NotPresent; | |
2311 | |
2312 TRACE_FUNCTION("setatPlusCSCS()"); | |
2313 | |
2314 cl = parse ( cl, "s", (LONG) sizeof (txtChset), txtChset); | |
2315 | |
2316 if ( strcmp ( txtChset, "GSM" ) EQ 0 ) | |
2317 chset = CSCS_CHSET_Gsm; | |
2318 else if ( strcmp ( txtChset, "IRA" ) EQ 0 ) | |
2319 chset = CSCS_CHSET_Ira; | |
2320 else if ( strcmp ( txtChset, "PCCP437" ) EQ 0 ) | |
2321 chset = CSCS_CHSET_Pccp_437; | |
2322 else if ( strcmp ( txtChset, "PCDN" ) EQ 0 ) | |
2323 chset = CSCS_CHSET_Pcdn; | |
2324 else if ( strcmp ( txtChset, "8859-1" ) EQ 0 ) | |
2325 chset = CSCS_CHSET_8859_1; | |
2326 else if ( strcmp ( txtChset, "HEX" ) EQ 0 ) | |
2327 chset = CSCS_CHSET_Hex; | |
2328 else if ( strcmp ( txtChset, "UCS2" ) EQ 0 ) | |
2329 chset = CSCS_CHSET_Ucs2; | |
2330 | |
2331 if ( !cl OR chset EQ CSCS_CHSET_NotPresent ) | |
2332 { | |
2333 cmdCmeError ( CME_ERR_OpNotAllow ); | |
2334 return ATI_FAIL; | |
2335 } | |
2336 | |
2337 #ifdef FF_ATI_BAT | |
2338 | |
2339 { | |
2340 T_BAT_cmd_send cmd; | |
2341 T_BAT_cmd_set_plus_cscs cscs; | |
2342 | |
2343 cmd.ctrl_params=BAT_CMD_SET_PLUS_CSCS; | |
2344 cmd.params.ptr_set_plus_cscs=&cscs; | |
2345 /* | |
2346 * This relies on T_BAT_plus_cscs being identical to | |
2347 * T_ACI_CSCS_CHSET. It is, apart from the NotPresent | |
2348 * value, which is taken care of earlier in this | |
2349 * function. | |
2350 */ | |
2351 cscs.cs=(T_BAT_plus_cscs_cs)chset; | |
2352 bat_send(ati_bat_get_client(srcId), &cmd); | |
2353 return(ATI_EXCT); | |
2354 } | |
2355 | |
2356 #else | |
2357 | |
2358 ati_user_output_cfg[srcId].cscsChset = chset; | |
2359 return ATI_CMPL; | |
2360 | |
2361 #endif | |
2362 } | |
2363 | |
2364 GLOBAL T_ATI_RSLT queatPlusCSCS (char *cl, UBYTE srcId) | |
2365 { | |
2366 TRACE_FUNCTION("queatPlusCSCS()"); | |
2367 | |
2368 #ifdef FF_ATI_BAT | |
2369 { | |
2370 T_BAT_cmd_send cmd; | |
2371 T_BAT_no_parameter dummy; | |
2372 | |
2373 cmd.ctrl_params=BAT_CMD_QUE_PLUS_CSCS; | |
2374 dummy.bat_dummy = 0xFF; | |
2375 cmd.params.ptr_que_plus_cscs = &dummy; | |
2376 bat_send(ati_bat_get_client(srcId), &cmd); | |
2377 } | |
2378 return(ATI_EXCT); | |
2379 | |
2380 #else /* no FF_ATI_BAT */ | |
2381 | |
2382 strcpy ( g_sa, "+CSCS: "); | |
2383 | |
2384 switch ( ati_user_output_cfg[srcId].cscsChset ) | |
2385 { | |
2386 case (CSCS_CHSET_Ira ): strcat (g_sa,"\"IRA\"" ); break; | |
2387 case (CSCS_CHSET_Pcdn ): strcat (g_sa,"\"PCDN\"" ); break; | |
2388 case (CSCS_CHSET_8859_1 ): strcat (g_sa,"\"8859-1\"" ); break; | |
2389 case (CSCS_CHSET_Pccp_437): strcat (g_sa,"\"PCCP437\""); break; | |
2390 case (CSCS_CHSET_Gsm ): strcat (g_sa,"\"GSM\"" ); break; | |
2391 case (CSCS_CHSET_Hex ): strcat (g_sa,"\"HEX\"" ); break; | |
2392 case (CSCS_CHSET_Ucs2 ): strcat (g_sa,"\"UCS2\"" ); break; | |
2393 | |
2394 /* | |
2395 *----------------------------------------------------------- | |
2396 * This case will be prevented during settings procedure of | |
2397 * the TE character set ( CSCS=... ) | |
2398 *----------------------------------------------------------- | |
2399 */ | |
2400 default: cmdCmeError ( CME_ERR_Unknown ); return ATI_FAIL; | |
2401 } | |
2402 | |
2403 io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT ); | |
2404 return ATI_CMPL; | |
2405 | |
2406 #endif /* no FF_ATI_BAT */ | |
2407 } | |
2408 | |
2409 /* | |
2410 +--------------------------------------------------------------------+ | |
2411 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2412 | STATE : code ROUTINE : atPlusCMEE | | |
2413 +--------------------------------------------------------------------+ | |
2414 | |
2415 PURPOSE : +CMEE command (Error display mode) | |
2416 */ | |
2417 | |
2418 GLOBAL T_ATI_RSLT setatPlusCMEE(CHAR *cl, UBYTE srcId) | |
2419 { | |
2420 SHORT val; | |
2421 | |
2422 TRACE_FUNCTION("setatPLusCMEE()"); | |
2423 | |
2424 cl=parse(cl,"r",&val); | |
2425 if ( !cl OR val > CMEE_MOD_Verbose OR val < CMEE_MOD_Disable ) | |
2426 { | |
2427 cmdAtError(atError); | |
2428 return ATI_FAIL; | |
2429 } | |
2430 else | |
2431 { | |
2432 TRACE_EVENT_P2("setatPlusCMEE: srcId = %d Value = %d", srcId, val); | |
2433 ati_user_output_cfg[srcId].CMEE_stat = (UBYTE)val; | |
2434 return ATI_CMPL; | |
2435 } | |
2436 } | |
2437 | |
2438 | |
2439 /* query function */ | |
2440 | |
2441 GLOBAL T_ATI_RSLT queatPlusCMEE(CHAR *cl, UBYTE srcId) | |
2442 { | |
2443 TRACE_FUNCTION("queatPLusCMEE()"); | |
2444 | |
2445 TRACE_EVENT_P1("queatPlusCMEE: srcId = %d", srcId); | |
2446 resp_disp(srcId, cl,"b",&ati_user_output_cfg[srcId].CMEE_stat); | |
2447 return ATI_CMPL; | |
2448 } | |
2449 | |
2450 /* | |
2451 +--------------------------------------------------------------------+ | |
2452 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2453 | STATE : code ROUTINE : atPlusGCAP | | |
2454 +--------------------------------------------------------------------+ | |
2455 | |
2456 PURPOSE : +GCAP command (capability information) | |
2457 */ | |
2458 GLOBAL T_ATI_RSLT atPlusGCAP(char *cl, UBYTE srcId) | |
2459 { | |
2460 if (*cl EQ '\0') | |
2461 { | |
2462 #ifdef FAX_AND_DATA | |
2463 | |
2464 #ifdef FF_FAX | |
2465 | |
2466 #ifdef V42BIS | |
2467 sprintf(g_sa,"+GCAP: +CGSM,+FCLASS,+DS"); | |
2468 #else | |
2469 sprintf(g_sa,"+GCAP: +CGSM,+FCLASS"); | |
2470 #endif | |
2471 | |
2472 #else /* no FAX */ | |
2473 | |
2474 #ifdef V42BIS | |
2475 sprintf(g_sa,"+GCAP: +CGSM,+DS"); | |
2476 #else | |
2477 sprintf(g_sa,"+GCAP: +CGSM"); | |
2478 #endif | |
2479 | |
2480 #endif /* FF_FAX */ | |
2481 | |
2482 #else /* Voice only */ | |
2483 | |
2484 sprintf(g_sa,"+GCAP: +CGSM"); | |
2485 | |
2486 #endif /* FAX_AND_DATA */ | |
2487 | |
2488 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
2489 return ATI_CMPL; | |
2490 } | |
2491 else | |
2492 { | |
2493 cmdAtError(atError); | |
2494 return ATI_FAIL; | |
2495 } | |
2496 } | |
2497 | |
2498 /* | |
2499 +--------------------------------------------------------------------+ | |
2500 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2501 | STATE : code ROUTINE : atPercentCCBS | | |
2502 +--------------------------------------------------------------------+ | |
2503 | |
2504 PURPOSE : %CCBS command (Call Completion to Busy Subscriber) | |
2505 */ | |
2506 | |
2507 GLOBAL T_ATI_RSLT setatPercentCCBS(char *cl, UBYTE srcId) | |
2508 { | |
2509 SHORT mode = ACI_NumParmNotPresent; | |
2510 SHORT idx = ACI_NumParmNotPresent; | |
2511 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
2512 T_ACI_RETURN ret = AT_FAIL; | |
2513 | |
2514 TRACE_FUNCTION("setatPercentCCBS()"); | |
2515 | |
2516 cl = parse (cl,"rr",&mode,&idx); | |
2517 if(!cl OR (mode NEQ ACI_NumParmNotPresent AND (mode > 1 OR mode < 0))) | |
2518 { | |
2519 cmdCmeError (CME_ERR_OpNotAllow); | |
2520 return ATI_FAIL; | |
2521 } | |
2522 | |
2523 if( mode NEQ ACI_NumParmNotPresent ) | |
2524 at.flags.CCBS_stat=(UBYTE)mode; | |
2525 | |
2526 #ifdef FF_ATI_BAT | |
2527 | |
2528 if (idx NEQ ACI_NumParmNotPresent) | |
2529 { | |
2530 T_BAT_cmd_send cmd; | |
2531 T_BAT_cmd_set_percent_ccbs ccbs; | |
2532 | |
2533 cmd.ctrl_params=BAT_CMD_SET_PERCENT_CCBS; | |
2534 cmd.params.ptr_set_percent_ccbs=&ccbs; | |
2535 ccbs.idx=(T_BAT_percent_ccbs_idx)idx; | |
2536 bat_send(ati_bat_get_client(srcId), &cmd); | |
2537 return(ATI_EXCT); | |
2538 } | |
2539 else | |
2540 { | |
2541 return(ATI_CMPL); | |
2542 } | |
2543 | |
2544 #else /* no FF_ATI_BAT */ | |
2545 | |
2546 if( idx NEQ ACI_NumParmNotPresent ) | |
2547 { | |
2548 ret = sAT_PercentCCBS((T_ACI_CMD_SRC)srcId, idx); | |
2549 if( ret NEQ AT_EXCT ) | |
2550 { | |
2551 cmdCmeError(CME_ERR_Unknown); | |
2552 return ATI_FAIL; | |
2553 } | |
2554 src_params->curAtCmd = AT_CMD_CCBS; | |
2555 } | |
2556 else | |
2557 { | |
2558 ret = AT_CMPL; | |
2559 } | |
2560 return (map_aci_2_ati_rslt(ret)); | |
2561 | |
2562 #endif /* no FF_ATI_BAT */ | |
2563 } | |
2564 | |
2565 GLOBAL T_ATI_RSLT queatPercentCCBS(char *cl, UBYTE srcId) | |
2566 { | |
2567 T_ACI_RETURN ret = AT_FAIL; | |
2568 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
2569 | |
2570 TRACE_FUNCTION("queatPercentCCBS()"); | |
2571 | |
2572 ret = qAT_PercentCCBS((T_ACI_CMD_SRC)srcId); | |
2573 | |
2574 if( ret NEQ AT_EXCT ) | |
2575 { | |
2576 cmdCmeError(CME_ERR_Unknown); | |
2577 return ATI_FAIL; | |
2578 } | |
2579 src_params->curAtCmd = AT_CMD_CCBS; | |
2580 return (map_aci_2_ati_rslt(ret)); | |
2581 } | |
2582 | |
2583 | |
2584 /* | |
2585 +--------------------------------------------------------------------+ | |
2586 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2587 | STATE : code ROUTINE : atPlusCMUX | | |
2588 +--------------------------------------------------------------------+ | |
2589 | |
2590 PURPOSE : +CMUX command (multiplexer) | |
2591 */ | |
2592 GLOBAL T_ATI_RSLT setatPlusCMUX (char *cl, UBYTE srcId) | |
2593 { | |
2594 T_ACI_RETURN ret = AT_FAIL; | |
2595 SHORT mode = ACI_NumParmNotPresent; | |
2596 SHORT subset = 0; /* default value */ | |
2597 UBYTE port_speed = NOT_PRESENT_8BIT; | |
2598 int N1 = 64; | |
2599 /* default value in advanced mode (other modes not supported */ | |
2600 SHORT T1 = 10; /* (100 ms) */ | |
2601 SHORT N2 = 3; | |
2602 SHORT T2 = 30; /* (30 ms) */ | |
2603 SHORT T3 = 10; /* (10 s) */ | |
2604 SHORT k = 2; | |
2605 | |
2606 TRACE_FUNCTION("setatPlusCMUX()"); | |
2607 | |
2608 cl = parse (cl,"rrrdrrrrr",&mode,&subset,&port_speed,&N1,&T1,&N2,&T2,&T3,&k); | |
2609 if (!cl) | |
2610 { | |
2611 cmdCmeError(CME_ERR_OpNotAllow); | |
2612 return ATI_FAIL; | |
2613 } | |
2614 | |
2615 #ifdef DTI | |
2616 /* values not supported */ | |
2617 if ( mode NEQ 1 | |
2618 OR subset NEQ 0 | |
2619 OR ((port_speed NEQ NOT_PRESENT_8BIT) | |
2620 AND (convert_mux_port_speed(port_speed) EQ BD_RATE_NotPresent)) | |
2621 OR N1 < 1 OR N1 > 32768 | |
2622 OR T1 < 1 OR T1 > 255 | |
2623 OR N2 < 0 OR N2 > 100 | |
2624 OR T2 < 2 OR T2 > 255 | |
2625 OR T3 < 1 OR T3 > 255 | |
2626 OR k < 1 OR k > 7 ) | |
2627 { | |
2628 TRACE_EVENT("at least one value is beyond capabilities"); | |
2629 cmdCmeError(CME_ERR_OpNotAllow); | |
2630 return ATI_FAIL; | |
2631 } | |
2632 | |
2633 #ifdef FF_ATI_BAT | |
2634 | |
2635 { | |
2636 T_BAT_cmd_send cmd; | |
2637 T_BAT_cmd_set_plus_cmux cmux; | |
2638 | |
2639 cmd.ctrl_params=BAT_CMD_SET_PLUS_CMUX; | |
2640 cmd.params.ptr_set_plus_cmux=&cmux; | |
2641 | |
2642 cmux.mode=(T_BAT_plus_cmux_mode)mode; | |
2643 cmux.subset=(T_BAT_plus_cmux_subset)subset; | |
2644 cmux.port_speed=(T_BAT_plus_cmux_port_speed)port_speed; | |
2645 cmux.n1=(U16)N1; | |
2646 cmux.t1=(U8)T1; | |
2647 cmux.n2=(U8)N2; | |
2648 cmux.t2=(U8)T2; | |
2649 cmux.t3=(U8)T3; | |
2650 cmux.k=(S16)k; | |
2651 | |
2652 bat_send(ati_bat_get_client(srcId), &cmd); | |
2653 return(ATI_EXCT); | |
2654 } | |
2655 | |
2656 #else /* no FF_ATI_BAT */ | |
2657 | |
2658 ret = sAT_PlusCMUX((T_ACI_CMD_SRC)srcId, | |
2659 (UBYTE)mode, | |
2660 (UBYTE)subset, | |
2661 port_speed, | |
2662 (USHORT)N1, | |
2663 (UBYTE)T1, | |
2664 (UBYTE)N2, | |
2665 (UBYTE)T2, | |
2666 (UBYTE)T3); | |
2667 | |
2668 #endif /* no FF_ATI_BAT */ | |
2669 | |
2670 #endif /* DTI */ | |
2671 | |
2672 if( ret EQ AT_FAIL ) | |
2673 { | |
2674 cmdCmeError(CME_ERR_Unknown); | |
2675 return ATI_FAIL; | |
2676 } | |
2677 return ATI_CMPL_NO_OUTPUT; | |
2678 } | |
2679 | |
2680 GLOBAL T_ATI_RSLT tesatPlusCMUX (char *cl, UBYTE srcId) | |
2681 { | |
2682 TRACE_FUNCTION("tesatPlusCMUX()"); | |
2683 | |
2684 sprintf(g_sa,"+CMUX: %s","(1),(0),(1-5),(10-100),(1-255),(0-100),(2-255),(1-255),(1-7)"); | |
2685 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
2686 | |
2687 io_sendConfirm(srcId, cmdAtError(atOk), ATI_NORMAL_OUTPUT); | |
2688 | |
2689 cmdErrStr = NULL; | |
2690 | |
2691 return ATI_CMPL_NO_OUTPUT; | |
2692 } | |
2693 | |
2694 GLOBAL T_ATI_RSLT queatPlusCMUX (char *cl, UBYTE srcId) | |
2695 { | |
2696 T_ACI_RETURN ret = AT_FAIL; | |
2697 UBYTE mode; | |
2698 UBYTE subset; | |
2699 UBYTE port_speed; | |
2700 USHORT N1; | |
2701 UBYTE T1; | |
2702 UBYTE N2; | |
2703 UBYTE T2; | |
2704 UBYTE T3; | |
2705 SHORT k = 2; | |
2706 | |
2707 TRACE_FUNCTION("queatPlusCMUX()"); | |
2708 | |
2709 #ifdef FF_ATI_BAT | |
2710 { | |
2711 T_BAT_cmd_send cmd; | |
2712 T_BAT_no_parameter dummy; | |
2713 | |
2714 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CMUX; | |
2715 dummy.bat_dummy = 0xFF; | |
2716 cmd.params.ptr_que_plus_cmux = &dummy; | |
2717 bat_send(ati_bat_get_client(srcId), &cmd); | |
2718 return(ATI_EXCT); | |
2719 } | |
2720 #else /* no FF_ATI_BAT */ | |
2721 | |
2722 #ifdef DTI | |
2723 ret = qAT_PlusCMUX((T_ACI_CMD_SRC)srcId, | |
2724 &mode, | |
2725 &subset, | |
2726 &port_speed, | |
2727 &N1, | |
2728 &T1, | |
2729 &N2, | |
2730 &T2, | |
2731 &T3); | |
2732 if (ret EQ AT_CMPL) | |
2733 { | |
2734 sprintf(g_sa,"+CMUX: %d,%d,%d,%d,%d,%d,%d,%d,%d", mode, subset, port_speed, N1, T1, N2, T2, T3, k); | |
2735 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
2736 return ATI_CMPL; | |
2737 } | |
2738 else if (ret EQ AT_FAIL) | |
2739 { | |
2740 cmdCmeError(CME_ERR_Unknown); | |
2741 } | |
2742 #endif /* DTI */ | |
2743 return ATI_FAIL; | |
2744 | |
2745 #endif /* no FF_ATI_BAT */ | |
2746 } | |
2747 | |
2748 /* | |
2749 +--------------------------------------------------------------------+ | |
2750 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2751 | STATE : code ROUTINE : atPlusIPR | | |
2752 +--------------------------------------------------------------------+ | |
2753 | |
2754 PURPOSE : +IPR command (DTE speed setting) | |
2755 */ | |
2756 | |
2757 GLOBAL T_ATI_RSLT setatPlusIPR(char *cl, UBYTE srcId) | |
2758 { | |
2759 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
2760 T_ACI_BD_RATE speed; | |
2761 char *end; | |
2762 | |
2763 src_params->curAtCmd = AT_CMD_IPR; | |
2764 | |
2765 switch ( strtol(cl, &end, 10) ) | |
2766 { | |
2767 case 0: speed = BD_RATE_AUTO; break; | |
2768 case 75: speed = BD_RATE_75; break; | |
2769 case 150: speed = BD_RATE_150; break; | |
2770 case 300: speed = BD_RATE_300; break; | |
2771 case 600: speed = BD_RATE_600; break; | |
2772 case 1200: speed = BD_RATE_1200; break; | |
2773 case 2400: speed = BD_RATE_2400; break; | |
2774 case 4800: speed = BD_RATE_4800; break; | |
2775 case 7200: speed = BD_RATE_7200; break; | |
2776 case 9600: speed = BD_RATE_9600; break; | |
2777 case 14400: speed = BD_RATE_14400; break; | |
2778 case 19200: speed = BD_RATE_19200; break; | |
2779 case 28800: speed = BD_RATE_28800; break; | |
2780 case 33900: speed = BD_RATE_33900; break; | |
2781 case 38400: speed = BD_RATE_38400; break; | |
2782 case 57600: speed = BD_RATE_57600; break; | |
2783 case 115200: speed = BD_RATE_115200; break; | |
2784 case 203125: speed = BD_RATE_203125; break; | |
2785 case 406250: speed = BD_RATE_406250; break; | |
2786 case 812500: speed = BD_RATE_812500; break; | |
2787 default: | |
2788 cmdCmeError(CME_ERR_OpNotSupp); | |
2789 return ATI_FAIL; | |
2790 } | |
2791 | |
2792 #ifdef FF_ATI_BAT | |
2793 { | |
2794 T_BAT_cmd_send cmd; | |
2795 T_BAT_cmd_set_plus_ipr my_bat_set_plus_ipr; | |
2796 | |
2797 TRACE_FUNCTION("setatPlusIPR() calls bat_send() <=== as APPLICATION"); | |
2798 | |
2799 memset(&my_bat_set_plus_ipr, 0, sizeof(my_bat_set_plus_ipr)); | |
2800 cmd.ctrl_params = BAT_CMD_SET_PLUS_IPR; | |
2801 cmd.params.ptr_set_plus_ipr = &my_bat_set_plus_ipr; | |
2802 | |
2803 my_bat_set_plus_ipr.rate = (T_BAT_plus_ipr_rate)speed; | |
2804 | |
2805 bat_send(ati_bat_get_client(srcId), &cmd); | |
2806 | |
2807 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
2808 } | |
2809 #else /* OLD FUNCTION BODY */ | |
2810 | |
2811 TRACE_FUNCTION("setatPlusIPR()"); | |
2812 | |
2813 #ifdef UART | |
2814 | |
2815 if(!end) | |
2816 { | |
2817 cmdCmeError(CME_ERR_OpNotSupp); | |
2818 return ATI_FAIL; | |
2819 } | |
2820 | |
2821 switch ( sAT_PlusIPR((T_ACI_CMD_SRC)srcId, speed) ) | |
2822 { | |
2823 case (AT_CMPL): /* operation completed */ | |
2824 return ATI_CMPL_NO_OUTPUT; /* OK was already sent at old baudrate by sAT_PlusIPR, | |
2825 so must not be sent twice! */ | |
2826 default: | |
2827 cmdCmeError(CME_ERR_NotPresent); | |
2828 return ATI_FAIL; | |
2829 } | |
2830 #else | |
2831 cmdCmeError(CME_ERR_NotPresent); | |
2832 return ATI_FAIL; | |
2833 | |
2834 #endif /* UART */ | |
2835 | |
2836 #endif /* no FF_ATI_BAT*/ | |
2837 } | |
2838 | |
2839 GLOBAL T_ATI_RSLT queatPlusIPR(char *cl, UBYTE srcId) | |
2840 { | |
2841 T_ACI_BD_RATE rate; | |
2842 int rate_value; | |
2843 | |
2844 TRACE_FUNCTION("queatPlusIPR()"); | |
2845 #ifdef DTI | |
2846 if ( AT_CMPL EQ qAT_PlusIPR((T_ACI_CMD_SRC)srcId, &rate) ) | |
2847 { | |
2848 switch ( rate ) | |
2849 { | |
2850 case BD_RATE_AUTO: rate_value = 0; break; | |
2851 case BD_RATE_75: rate_value = 75; break; | |
2852 case BD_RATE_150: rate_value = 150; break; | |
2853 case BD_RATE_300: rate_value = 300; break; | |
2854 case BD_RATE_600: rate_value = 600; break; | |
2855 case BD_RATE_1200: rate_value = 1200; break; | |
2856 case BD_RATE_2400: rate_value = 2400; break; | |
2857 case BD_RATE_4800: rate_value = 4800; break; | |
2858 case BD_RATE_7200: rate_value = 7200; break; | |
2859 case BD_RATE_9600: rate_value = 9600; break; | |
2860 case BD_RATE_14400: rate_value = 14400; break; | |
2861 case BD_RATE_19200: rate_value = 19200; break; | |
2862 case BD_RATE_28800: rate_value = 28800; break; | |
2863 case BD_RATE_33900: rate_value = 33900; break; | |
2864 case BD_RATE_38400: rate_value = 38400; break; | |
2865 case BD_RATE_57600: rate_value = 57600; break; | |
2866 case BD_RATE_115200: rate_value = 115200; break; | |
2867 case BD_RATE_203125: rate_value = 203125; break; | |
2868 case BD_RATE_406250: rate_value = 406250; break; | |
2869 case BD_RATE_812500: rate_value = 812500; break; | |
2870 default: rate_value = 0; break; | |
2871 } | |
2872 | |
2873 sprintf(g_sa,"+IPR: %d", rate_value); | |
2874 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
2875 return ATI_CMPL; | |
2876 } | |
2877 #endif | |
2878 cmdAtError(atError); | |
2879 return(ATI_FAIL); | |
2880 } | |
2881 /* | |
2882 +--------------------------------------------------------------------+ | |
2883 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2884 | STATE : code ROUTINE : atPlusICF | | |
2885 +--------------------------------------------------------------------+ | |
2886 | |
2887 PURPOSE : +ICF command (DTE character frame setting) | |
2888 */ | |
2889 | |
2890 GLOBAL T_ATI_RSLT setatPlusICF(char *cl, UBYTE srcId) | |
2891 { | |
2892 T_ACI_BS_FRM format = BS_FRM_NotPresent; | |
2893 T_ACI_BS_PAR parity = BS_PAR_NotPresent; | |
2894 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
2895 | |
2896 TRACE_FUNCTION("setatPlusICF()"); | |
2897 | |
2898 cl=parse(cl,"dd",&format,&parity); | |
2899 | |
2900 if(!cl) | |
2901 { | |
2902 cmdAtError(atError); | |
2903 return ATI_FAIL; | |
2904 } | |
2905 #ifdef DTI | |
2906 | |
2907 #ifdef FF_ATI_BAT | |
2908 | |
2909 { | |
2910 T_BAT_cmd_send cmd; | |
2911 T_BAT_cmd_set_plus_icf icf; | |
2912 | |
2913 cmd.ctrl_params=BAT_CMD_SET_PLUS_ICF; | |
2914 cmd.params.ptr_set_plus_icf=&icf; | |
2915 | |
2916 /* | |
2917 * This relies on T_ACI_BS_FRM being identical to | |
2918 * T_BAT_framing_format and T_ACI_BS_PAR being identical | |
2919 * to T_BAT_framing_parity. | |
2920 */ | |
2921 icf.framing_format=(T_BAT_framing_format)format; | |
2922 icf.framing_parity=(T_BAT_framing_parity)parity; | |
2923 | |
2924 bat_send(ati_bat_get_client(srcId), &cmd); | |
2925 } | |
2926 | |
2927 src_params->curAtCmd=AT_CMD_ICF; | |
2928 | |
2929 return(ATI_EXCT); | |
2930 | |
2931 #else /* no FF_ATI_BAT */ | |
2932 | |
2933 switch ( sAT_PlusICF((T_ACI_CMD_SRC)srcId, format, parity) ) | |
2934 { | |
2935 case (AT_CMPL): /*operation completed*/ | |
2936 return ATI_CMPL; | |
2937 case (AT_EXCT): | |
2938 src_params->curAtCmd = AT_CMD_ICF; | |
2939 return ATI_EXCT; | |
2940 default: | |
2941 cmdAtError(atError); /*Command failed*/ | |
2942 return ATI_FAIL; | |
2943 } | |
2944 | |
2945 #endif /* no FF_ATI_BAT */ | |
2946 | |
2947 #else | |
2948 cmdAtError(atError); /*Command failed*/ | |
2949 return ATI_FAIL; | |
2950 #endif | |
2951 } | |
2952 | |
2953 GLOBAL T_ATI_RSLT queatPlusICF(char *cl, UBYTE srcId) | |
2954 { | |
2955 #ifndef FF_ATI_BAT | |
2956 T_ACI_BS_FRM format; | |
2957 T_ACI_BS_PAR parity; | |
2958 #endif | |
2959 | |
2960 TRACE_FUNCTION("queatPlusICF()"); | |
2961 | |
2962 #ifdef DTI | |
2963 | |
2964 #ifdef FF_ATI_BAT | |
2965 { | |
2966 T_BAT_cmd_send cmd; | |
2967 T_BAT_no_parameter dummy; | |
2968 | |
2969 cmd.ctrl_params = BAT_CMD_QUE_PLUS_ICF; | |
2970 dummy.bat_dummy = 0xFF; | |
2971 cmd.params.ptr_que_plus_icf = &dummy; | |
2972 bat_send(ati_bat_get_client(srcId), &cmd); | |
2973 return(ATI_EXCT); | |
2974 } | |
2975 #else /* no FF_ATI_BAT */ | |
2976 | |
2977 switch ( qAT_PlusICF((T_ACI_CMD_SRC)srcId,&format,&parity) ) | |
2978 { | |
2979 case AT_CMPL: | |
2980 if (format EQ BS_FRM_Dat8_Par1_St1 OR format EQ BS_FRM_Dat7_Par1_St1 ) | |
2981 { | |
2982 resp_disp(srcId, cl,"ee",&format,&parity); | |
2983 } | |
2984 else | |
2985 { | |
2986 resp_disp(srcId, cl,"e",&format); | |
2987 } | |
2988 return ATI_CMPL; | |
2989 } | |
2990 | |
2991 #endif /* no FF_ATI_BAT */ | |
2992 | |
2993 #endif /* DTI */ | |
2994 cmdAtError(atError); | |
2995 return ATI_FAIL; | |
2996 } | |
2997 | |
2998 GLOBAL T_ATI_RSLT setflowCntr(CHAR* cl, UBYTE srcId) | |
2999 { | |
3000 T_ACI_RX_FLOW_CTRL DCE_by_DTE = RX_FLOW_NotPresent; /* by TE: Rx flow control */ | |
3001 T_ACI_RX_FLOW_CTRL DTE_by_DCE = RX_FLOW_NotPresent; /* by TA: Tx flow control */ | |
3002 | |
3003 cl = parse (cl,"dd",&DCE_by_DTE,&DTE_by_DCE); | |
3004 | |
3005 if(!cl) | |
3006 { | |
3007 cmdAtError(atError); | |
3008 return ATI_FAIL; | |
3009 } | |
3010 | |
3011 #ifdef DTI | |
3012 switch ( sAT_PlusIFC((T_ACI_CMD_SRC)srcId, DCE_by_DTE, DTE_by_DCE) ) | |
3013 { | |
3014 case (AT_CMPL): /*operation completed*/ | |
3015 return ATI_CMPL; | |
3016 case (AT_EXCT): | |
3017 /* ATTENTION: no setting of 'curAtCmd' allowed because the value is set before */ | |
3018 return ATI_EXCT; | |
3019 default: | |
3020 cmdAtError(atError); /*Command failed*/ | |
3021 return ATI_FAIL; | |
3022 } | |
3023 #else | |
3024 cmdAtError(atError); /*Command failed*/ | |
3025 return ATI_FAIL; | |
3026 #endif | |
3027 } | |
3028 | |
3029 /* | |
3030 +--------------------------------------------------------------------+ | |
3031 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3032 | STATE : code ROUTINE : atPlusIFC | | |
3033 +--------------------------------------------------------------------+ | |
3034 | |
3035 PURPOSE : +IFC command (DTE DCE / DCE DTE flow control) | |
3036 */ | |
3037 | |
3038 GLOBAL T_ATI_RSLT setatPlusIFC(char *cl, UBYTE srcId) | |
3039 { | |
3040 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
3041 TRACE_FUNCTION("setatPlusIFC()"); | |
3042 | |
3043 src_params->curAtCmd = AT_CMD_IFC; | |
3044 return setflowCntr(cl, srcId); | |
3045 } | |
3046 | |
3047 | |
3048 GLOBAL T_ATI_RSLT queflowCntr(CHAR* cl, UBYTE srcId) | |
3049 { | |
3050 T_ACI_RX_FLOW_CTRL DCE_by_DTE; | |
3051 T_ACI_RX_FLOW_CTRL DTE_by_DCE; | |
3052 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
3053 | |
3054 #ifdef DTI | |
3055 if ( AT_CMPL EQ qAT_PlusIFC((T_ACI_CMD_SRC)srcId,&DCE_by_DTE,&DTE_by_DCE) ) | |
3056 { | |
3057 #ifdef FF_FAX | |
3058 if (src_params->curAtCmd EQ AT_CMD_FLO) | |
3059 { | |
3060 sprintf(g_sa,"+FLO: %d",DCE_by_DTE); | |
3061 } | |
3062 else | |
3063 #endif | |
3064 if (src_params->curAtCmd EQ AT_CMD_IFC) | |
3065 { | |
3066 sprintf(g_sa,"+IFC: %d,%d",DCE_by_DTE,DTE_by_DCE); | |
3067 } | |
3068 | |
3069 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
3070 return ATI_CMPL; | |
3071 } | |
3072 else | |
3073 { | |
3074 cmdAtError(atError); | |
3075 return ATI_FAIL; | |
3076 } | |
3077 #else | |
3078 cmdAtError(atError); | |
3079 return ATI_FAIL; | |
3080 #endif | |
3081 } | |
3082 | |
3083 /* | |
3084 +--------------------------------------------------------------------+ | |
3085 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3086 | STATE : code ROUTINE : atPlusIFC | | |
3087 +--------------------------------------------------------------------+ | |
3088 | |
3089 PURPOSE : +IFC command (DTE DCE / DCE DTE flow control) | |
3090 */ | |
3091 | |
3092 GLOBAL T_ATI_RSLT queatPlusIFC(char *cl, UBYTE srcId) | |
3093 { | |
3094 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
3095 TRACE_FUNCTION("queatPlusIFC()"); | |
3096 | |
3097 src_params->curAtCmd = AT_CMD_IFC; | |
3098 return queflowCntr(cl, srcId); | |
3099 } | |
3100 | |
3101 /* | |
3102 +--------------------------------------------------------------------+ | |
3103 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3104 | STATE : code ROUTINE : atPlusILRR | | |
3105 +--------------------------------------------------------------------+ | |
3106 | |
3107 PURPOSE : +ILRR command (display +ILRR setting) | |
3108 */ | |
3109 | |
3110 GLOBAL T_ATI_RSLT setatPlusILRR(char *cl, UBYTE srcId) | |
3111 { | |
3112 SHORT val=-1; | |
3113 | |
3114 TRACE_FUNCTION("setatPLusILRR()"); | |
3115 | |
3116 cl = parse (cl,"r",&val); | |
3117 if(!cl OR val > 1 OR val < 0) | |
3118 { | |
3119 cmdAtError(atError); | |
3120 return ATI_FAIL; | |
3121 } | |
3122 ati_user_output_cfg[srcId].ILRR_stat=(UBYTE)val; | |
3123 return ATI_CMPL; | |
3124 } | |
3125 | |
3126 GLOBAL T_ATI_RSLT queatPlusILRR(char *cl, UBYTE srcId) | |
3127 { | |
3128 TRACE_FUNCTION("queatPLusILRR()"); | |
3129 | |
3130 resp_disp(srcId, cl,"b",&ati_user_output_cfg[srcId].ILRR_stat); | |
3131 return ATI_CMPL; | |
3132 } | |
3133 | |
3134 /* | |
3135 +--------------------------------------------------------------------+ | |
3136 | PROJECT : MODULE : ACI_CMD | | |
3137 | STATE : code ROUTINE : setatPlusCCLK | | |
3138 +--------------------------------------------------------------------+ | |
3139 | |
3140 PURPOSE : +CCLK command (Set the real time clock of the MT) | |
3141 */ | |
3142 GLOBAL T_ATI_RSLT setatPlusCCLK (char *cl, UBYTE srcId) | |
3143 { | |
3144 T_ACI_RETURN ret = AT_FAIL; | |
3145 T_ACI_RTC_DATE date_s; | |
3146 T_ACI_RTC_TIME time_s; | |
3147 char date_time_string[DATE_TIME_LENGTH+1]={0}; | |
3148 int items_conv = 0; | |
3149 U8 days = 0, months = 0; | |
3150 U8 hrs = 0, mins = 0, secs = 0; | |
3151 U8 years = 0; | |
3152 U8 tz = 0; /* to parse timezone from date_time_string */ | |
3153 SHORT timeZone = 0; | |
3154 char sign = '+'; | |
3155 | |
3156 TRACE_FUNCTION("setatPlusCCLK()"); | |
3157 | |
3158 cl=parse(cl,"s", DATE_TIME_LENGTH, date_time_string); | |
3159 | |
3160 /* Expected format: yy/MM/dd,hh:mm:ss+zz (20 bytes). DATE_TIME_LENGTH(22 bytes) | |
3161 * allows length for yyyy/MM/dd,hh:mm:ss+zz */ | |
3162 if(!cl OR strlen(date_time_string) NEQ DATE_TIME_LENGTH-2) | |
3163 { | |
3164 cmdCmeError(CME_ERR_OpNotAllow); | |
3165 return (ATI_FAIL); | |
3166 } | |
3167 | |
3168 TRACE_EVENT_P1("Date and time are: %s",date_time_string); | |
3169 items_conv = parseTimeStamp( date_time_string, &years,&months,&days,&hrs,&mins,&secs,&sign,&tz); | |
3170 | |
3171 timeZone = tz; | |
3172 | |
3173 if (sign EQ '-') | |
3174 { | |
3175 timeZone = timeZone * (-1); | |
3176 } | |
3177 | |
3178 TRACE_EVENT_P1("items_conv %d",items_conv); | |
3179 TRACE_EVENT_P1("days %d",days); | |
3180 TRACE_EVENT_P1("months %d",months); | |
3181 TRACE_EVENT_P1("years %d",years); | |
3182 TRACE_EVENT_P1("hours %d",hrs); | |
3183 TRACE_EVENT_P1("mins %d",mins); | |
3184 TRACE_EVENT_P1("secs %d",secs); | |
3185 TRACE_EVENT_P1("sign %c",sign); | |
3186 TRACE_EVENT_P1("timeZone %d",timeZone); | |
3187 | |
3188 | |
3189 /* If 8 data items not extracted from date_time_string then date_time_string data with TZ info is incorrect. */ | |
3190 if ( items_conv NEQ MAX_TIME_STAMP_FIELDS ) | |
3191 { | |
3192 cmdCmeError(CME_ERR_OpNotAllow); | |
3193 return (ATI_FAIL); | |
3194 } | |
3195 | |
3196 #ifndef _SIMULATION_ | |
3197 /* Ensure 'years' passed in from the AT command is not in 4 digit format | |
3198 The spec requires the years to be passed in in 2 digit format | |
3199 Also ensure the sign char is either a '+' or '-' */ | |
3200 if ( (years > 99 ) OR | |
3201 ((sign NEQ '-') AND (sign NEQ '+')) OR | |
3202 ( timeZone < (-48)) OR (timeZone > 48) | |
3203 ) | |
3204 { | |
3205 cmdCmeError(CME_ERR_OpNotAllow); | |
3206 return (ATI_FAIL); | |
3207 } | |
3208 #else /* _SIMULATION_ */ | |
3209 /* On the target code these checks are done in the RTC code. In the simulation code- | |
3210 the RTC routines are not used so these checks have to be done. */ | |
3211 if ( (years < 0) OR (years > 99) | |
3212 OR (months < 1) OR (months > 12) | |
3213 OR (days < 1) OR (days > 31) | |
3214 OR (hrs < 0) OR (hrs > 23) | |
3215 OR (mins < 0) OR (mins > 59) | |
3216 OR (secs < 0) OR (secs > 59) | |
3217 OR (timeZone < (-48)) OR (timeZone > 48) | |
3218 ) | |
3219 { | |
3220 cmdCmeError(CME_ERR_OpNotAllow); | |
3221 return (ATI_FAIL); | |
3222 } | |
3223 #endif /* _SIMULATION_ */ | |
3224 | |
3225 | |
3226 /* Populate date time structs */ | |
3227 date_s.day = days; | |
3228 date_s.month = months; | |
3229 date_s.year = years + 2000; /* Convert years to 4 digit format for passing to lower layer RTC function */ | |
3230 time_s.hour = hrs; | |
3231 time_s.minute = mins; | |
3232 time_s.PM_flag = 0; | |
3233 time_s.second = secs; | |
3234 time_s.format = TIME_FORMAT_24HOUR; | |
3235 | |
3236 /* Pass separated date and time and timezone info to set the clock */ | |
3237 | |
3238 #ifdef FF_ATI_BAT | |
3239 | |
3240 { | |
3241 T_BAT_cmd_send cmd; | |
3242 T_BAT_cmd_set_plus_cclk cclk; | |
3243 | |
3244 cmd.ctrl_params=BAT_CMD_SET_PLUS_CCLK; | |
3245 cmd.params.ptr_set_plus_cclk=&cclk; | |
3246 | |
3247 cclk.year=(U8)date_s.year; | |
3248 cclk.month=(U8)date_s.month; | |
3249 cclk.day=(U8)date_s.day; | |
3250 | |
3251 cclk.hour=(U8)time_s.hour; | |
3252 | |
3253 cclk.minutes=(U8)time_s.minute; | |
3254 cclk.seconds=(U8)time_s.second; | |
3255 | |
3256 cclk.time_zone=(S8)timeZone; | |
3257 | |
3258 bat_send(ati_bat_get_client(srcId), &cmd); | |
3259 } | |
3260 | |
3261 return(ATI_EXCT); | |
3262 | |
3263 #else /* no FF_ATI_BAT */ | |
3264 | |
3265 ret = sAT_PlusCCLK ( (T_ACI_CMD_SRC)srcId, &date_s, &time_s, timeZone); | |
3266 | |
3267 TRACE_EVENT_P1("sAT_PlusCCLK ret = %d", ret); | |
3268 | |
3269 /* Deal with return value */ | |
3270 | |
3271 switch (ret) | |
3272 { | |
3273 case (AT_CMPL): /*operation completed*/ | |
3274 break; | |
3275 | |
3276 default: | |
3277 cmdCmeError(CME_ERR_Unknown); /*Command failed*/ | |
3278 break; | |
3279 } | |
3280 return (map_aci_2_ati_rslt(ret)); | |
3281 | |
3282 #endif /* no FF_ATI_BAT */ | |
3283 } | |
3284 | |
3285 /* | |
3286 +--------------------------------------------------------------------+ | |
3287 | PROJECT : MODULE : ACI_CMD | | |
3288 | STATE : code ROUTINE : queatPlusCCLK | | |
3289 +--------------------------------------------------------------------+ | |
3290 | |
3291 PURPOSE : +CCLK query command (Read the real time clock of the MT) | |
3292 */ | |
3293 GLOBAL T_ATI_RSLT queatPlusCCLK (char *cl, UBYTE srcId) | |
3294 { | |
3295 #ifndef FF_ATI_BAT | |
3296 T_ACI_RETURN ret = AT_FAIL; | |
3297 T_ACI_RTC_DATE date_s; /* Structures to obtain date time info */ | |
3298 T_ACI_RTC_TIME time_s; | |
3299 UBYTE days, months; | |
3300 UBYTE hrs, mins, secs; | |
3301 USHORT years; | |
3302 #if defined FF_TIMEZONE OR defined _SIMULATION_ | |
3303 char sign ; | |
3304 #endif /* defined FF_TIMEZONE OR defined _SIMULATION_ */ | |
3305 int tz ; | |
3306 char *me="+CCLK: "; | |
3307 #endif | |
3308 | |
3309 | |
3310 TRACE_FUNCTION("queatPlusCCLK()"); | |
3311 | |
3312 #ifdef FF_ATI_BAT | |
3313 { | |
3314 T_BAT_cmd_send cmd; | |
3315 T_BAT_no_parameter dummy; | |
3316 | |
3317 cmd.ctrl_params=BAT_CMD_QUE_PLUS_CCLK; | |
3318 dummy.bat_dummy = 0xFF; | |
3319 cmd.params.ptr_que_plus_cclk = &dummy; | |
3320 bat_send(ati_bat_get_client(srcId), &cmd); | |
3321 return(ATI_EXCT); | |
3322 } | |
3323 #else /* no FF_ATI_BAT */ | |
3324 | |
3325 ret = qAT_PlusCCLK( (T_ACI_CMD_SRC)srcId, &date_s, &time_s, &tz); | |
3326 | |
3327 if (ret EQ AT_CMPL) | |
3328 { | |
3329 /* Command completed successfully */ | |
3330 /* convert time date struct data into string */ | |
3331 days = date_s.day; | |
3332 months = date_s.month; | |
3333 years = date_s.year; | |
3334 hrs = time_s.hour; | |
3335 mins = time_s.minute; | |
3336 secs = time_s.second; | |
3337 | |
3338 #ifndef _SIMULATION_ | |
3339 #ifdef FF_TIMEZONE | |
3340 if ( tz < 0) | |
3341 { | |
3342 sign = '-'; | |
3343 tz = tz * (-1); | |
3344 } | |
3345 else | |
3346 sign = '+'; | |
3347 #endif /* FF_TIMEZONE */ | |
3348 #else /* _SIMULATION_ */ | |
3349 sign = '-'; | |
3350 tz = tz * (-1); | |
3351 #endif /* _SIMULATION_ */ | |
3352 | |
3353 /* Convert years to 2 digit format for reporting back to user */ | |
3354 years = years - 2000; /* Subtract 2000 years from number returned */ | |
3355 | |
3356 TRACE_EVENT_P3("Date -> %d - %d - %d",days,months,years); | |
3357 TRACE_EVENT_P3("Time -> %d - %d - %d",hrs,mins,secs); | |
3358 /* Not using time_s.format or time_s.PM_flag */ | |
3359 | |
3360 /* CONVERT DATE TIME INFO INTO STRING FOR OUTPUTTING BACK TO DISPLAY */ | |
3361 | |
3362 #ifndef _SIMULATION_ | |
3363 | |
3364 #ifndef FF_TIMEZONE | |
3365 sprintf(g_sa, "%s\"%d/%d/%d,%d:%d:%d\"", me, years, months, days, hrs, mins, secs); | |
3366 #else /* FF_TIMEZONE */ | |
3367 TRACE_EVENT_P2("TimeZone -> %c%d", sign, tz); | |
3368 sprintf(g_sa, "%s\"%d/%d/%d,%d:%d:%d%c%d\"", me, years, months, days, hrs, mins, secs, sign, tz); | |
3369 #endif /* FF_TIMEZONE */ | |
3370 | |
3371 #else /* _SIMULATION_ */ | |
3372 TRACE_EVENT_P2("TimeZone -> %c%d", sign, tz); | |
3373 sprintf(g_sa, "%s\"%d/%d/%d,%d:%d:%d%c%d\"", me, years, months, days, hrs, mins, secs, sign, tz); | |
3374 #endif /* _SIMULATION_ */ | |
3375 | |
3376 /* REPORT DATE TIME INFO STRING */ | |
3377 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
3378 | |
3379 return ATI_CMPL; | |
3380 } | |
3381 else | |
3382 { | |
3383 cmdCmeError(CME_ERR_Unknown); | |
3384 return ATI_FAIL; | |
3385 } | |
3386 | |
3387 #endif /* no FF_ATI_BAT */ | |
3388 | |
3389 } | |
3390 #endif /* ATI_BAS_C */ | |
3391 | |
3392 |