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