FreeCalypso > hg > tcs211-c139

comparison g23m/condat/ms/src/aci/ati_cmd.c @ 0:509db1a7b7b8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial import: leo2moko-r1
author Space Falcon <falcon@ivan.Harhan.ORG>
date Mon, 01 Jun 2015 03:24:05 +0000
parents
children 98f5312a7d0b
comparison
equal deleted inserted replaced
-1:000000000000 0:509db1a7b7b8
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: Processing AT-Commands strings.
18 +-----------------------------------------------------------------------------
19 */
20 #ifndef ACI_CMD_C
21 #define ACI_CMD_C
22
23 #undef DUMMY_ATI_STRINGS
24
25 #include "aci_all.h"
26
27 #include "dti.h" /* functionality of the dti library */
28 #include "line_edit.h" /* SKA 2002-09-05 */
29 #include "aci_cmh.h"
30 #include "ati_cmd.h"
31 #include "aci_io.h"
32 #include "aci_cmd.h"
33 #include "l4_tim.h"
34
35 #include <stdarg.h>
36 #include <string.h>
37
38 #include "psa.h"
39 #include "cmh.h"
40
41 #include "aci_lst.h"
42 #include "dti_conn_mng.h"
43 #ifdef UART
44 #include "psa_uart.h"
45 #endif
46 #include "ati_io.h"
47 #include "aci_mem.h"
48
49 #ifdef SIM_TOOLKIT
50 #include "ati_src_sat.h"
51 #include "psa_cc.h"
52 #include "psa_sat.h"
53 #endif /* SIM_TOOLKIT */
54
55 #ifdef GPRS
56 #include "gaci_cmh.h"
57 #include "gaci_cmd.h"
58 #endif /* GPRS */
59
60 #include "aci_prs.h"
61
62
63 #ifndef _SIMULATION_
64 #ifdef UART
65 #include "cmh_uart.h"
66 #endif
67 #endif
68
69 #include "psa_sms.h"
70 #include "aci.h"
71 #include "ati_ext_mech.h"
72
73 #ifdef FF_ATI_BAT
74 #include "ati_bat.h"
75 #include "aci_bat.h"
76 #endif
77
78 #define OLD_NON_STANDARDIZED_ATCMD "&ABDEFHILMOPQSTVWXZ"
79
80 /*==== EXTERNALS ======================================================*/
81 EXTERN T_SMS_SHRD_PRM smsShrdPrm;
82 EXTERN T_ACI_CUSCFG_PARAMS cuscfgParams;
83
84 /*==== LOCALS =========================================================*/
85 LOCAL BOOL aci_SrchFwrdLst ( UBYTE srcId ,CHAR* searchFor );
86 LOCAL T_ATI_RSLT aci_FwrdToEXT ( T_ATI_SRC_PARAMS *src_params, T_LEDIT_ATCMD *cmd);
87 LOCAL BOOL aci_cmhActive ( UBYTE srcId );
88
89 LOCAL void send_output_type_signal (T_ATI_SRC_PARAMS *src_params, UBYTE output_type);
90 LOCAL void check_and_send_output_type_signal (T_ATI_SRC_PARAMS *src_params, CHAR *cmd);
91
92 LOCAL SHORT find_index(CHAR * cl);
93
94 /*==== EXPORT ======================================================*/
95
96 EXTERN CHAR *cmdCmsError ( T_ACI_CMS_ERR e );
97 EXTERN CHAR *cmdCmeError ( T_ACI_CME_ERR err );
98 EXTERN CHAR *cmdAtError (AtErrCode e);
99 EXTERN void io_sendChar (CHAR a, UBYTE srcId);
100
101 EXTERN T_ATI_RSLT atPercentCPRIM (char *cl, UBYTE srcId);
102 EXTERN T_ATI_RSLT atPlusCLAC (char *cl, UBYTE srcId);
103 EXTERN T_ATI_RSLT setatPlusGCI(char *cl, UBYTE srcId);
104 EXTERN T_ATI_RSLT queatPlusGCI(char *cl, UBYTE srcId);
105 EXTERN T_ATI_RSLT setatPlusCCWE(char *cl, UBYTE srcId);
106 EXTERN T_ATI_RSLT queatPlusCCWE(char *cl, UBYTE srcId);
107 EXTERN T_ATI_RSLT atPlusCGMI ( char *cl, UBYTE srcId );
108 EXTERN T_ATI_RSLT atPlusCGMM ( char *cl, UBYTE srcId );
109 EXTERN T_ATI_RSLT atPlusCGMR ( char *cl, UBYTE srcId );
110 EXTERN T_ATI_RSLT atPlusCGSN ( char *cl, UBYTE srcId );
111 EXTERN T_ATI_RSLT atPlusCSAS (CHAR *cl, UBYTE srcId);
112 EXTERN T_ATI_RSLT tesatPlusCSAS (CHAR *cl, UBYTE srcId);
113 EXTERN T_ATI_RSLT queatPlusCSAS (CHAR *cl, UBYTE srcId);
114 EXTERN T_ATI_RSLT setatPlusCLVL ( char *cl, UBYTE srcId );
115 EXTERN T_ATI_RSLT tesatPlusCLVL ( char *cl, UBYTE srcId );
116 EXTERN T_ATI_RSLT queatPlusCLVL ( char *cl, UBYTE srcId );
117 EXTERN T_ATI_RSLT setatPercentCCBS (CHAR *cl, UBYTE srcId);
118 EXTERN T_ATI_RSLT queatPercentCCBS (CHAR *cl, UBYTE srcId);
119 EXTERN T_ATI_RSLT atPlusCMGL(CHAR *cl, UBYTE srcId);
120 EXTERN T_ATI_RSLT tesatPlusCMGL(CHAR *cl, UBYTE srcId);
121 EXTERN T_ATI_RSLT queatPlusCMGL(CHAR *cl, UBYTE srcId);
122 EXTERN T_ATI_RSLT aciPrcsPlusCG(CHAR* cl, UBYTE srcId);
123 EXTERN T_ATI_RSLT setaciPrcsVolLevel(CHAR* cl, UBYTE srcId);
124 EXTERN T_ATI_RSLT tesaciPrcsVolLevel(CHAR* cl, UBYTE srcId);
125 EXTERN T_ATI_RSLT queaciPrcsVolLevel(CHAR* cl, UBYTE srcId);
126 EXTERN T_ATI_RSLT setatPlusCOPS (CHAR *cl, UBYTE srcId);
127 EXTERN T_ATI_RSLT tesatPlusCOPS (CHAR *cl, UBYTE srcId);
128 EXTERN T_ATI_RSLT queatPlusCOPS (CHAR *cl, UBYTE srcId);
129 EXTERN T_ATI_RSLT setatPercentCOPS (CHAR *cl, UBYTE srcId);
130 EXTERN T_ATI_RSLT tesatPercentCOPS (CHAR *cl, UBYTE srcId);
131 EXTERN T_ATI_RSLT queatPercentCOPS (CHAR *cl, UBYTE srcId);
132 EXTERN T_ATI_RSLT setatPlusCPOL (CHAR *cl, UBYTE srcId);
133 EXTERN T_ATI_RSLT tesatPlusCPOL (CHAR *cl, UBYTE srcId);
134 EXTERN T_ATI_RSLT queatPlusCPOL (CHAR *cl, UBYTE srcId);
135 EXTERN T_ATI_RSLT setatPlusCOPN (CHAR *cl, UBYTE srcId);
136 EXTERN T_ATI_RSLT setatPercentCOPN (CHAR *cl, UBYTE srcId);
137 EXTERN T_ATI_RSLT setatPlusCFUN (CHAR *cl, UBYTE srcId);
138 EXTERN T_ATI_RSLT queatPlusCFUN (CHAR *cl, UBYTE srcId);
139 EXTERN T_ATI_RSLT setatPlusCPIN (CHAR *cl, UBYTE srcId);
140 EXTERN T_ATI_RSLT queatPlusCPIN (CHAR *cl, UBYTE srcId);
141 EXTERN T_ATI_RSLT setatPlusCPAS (CHAR *cl, UBYTE srcId);
142
143 EXTERN T_ATI_RSLT setatPlusCLAE (CHAR *cl, UBYTE srcId);
144 EXTERN T_ATI_RSLT queatPlusCLAE (CHAR *cl, UBYTE srcId);
145
146 EXTERN T_ATI_RSLT setatPlusCLIP (char *cl, UBYTE srcId);
147 EXTERN T_ATI_RSLT setatPlusCDIP (char *cl, UBYTE srcId);
148 EXTERN T_ATI_RSLT queatPlusCLIP (CHAR *cl, UBYTE srcId);
149 EXTERN T_ATI_RSLT queatPlusCDIP (CHAR *cl, UBYTE srcId);
150 EXTERN T_ATI_RSLT setatPlusCLIR (CHAR *cl, UBYTE srcId);
151 EXTERN T_ATI_RSLT queatPlusCLIR (CHAR *cl, UBYTE srcId);
152 EXTERN T_ATI_RSLT setatPlusCOLP (CHAR *cl, UBYTE srcId);
153 EXTERN T_ATI_RSLT queatPlusCOLP (CHAR *cl, UBYTE srcId);
154 EXTERN T_ATI_RSLT setatPlusCMOD (CHAR *cl, UBYTE srcId);
155 EXTERN T_ATI_RSLT queatPlusCMOD (CHAR *cl, UBYTE srcId);
156 EXTERN T_ATI_RSLT setatPlusCSTA (CHAR *cl, UBYTE srcId);
157 EXTERN T_ATI_RSLT queatPlusCSTA (CHAR *cl, UBYTE srcId);
158 EXTERN T_ATI_RSLT setatPlusCHUP (char *cl, UBYTE srcId);
159 EXTERN T_ATI_RSLT setatPlusCLCK (CHAR *cl, UBYTE srcId);
160 EXTERN T_ATI_RSLT setatPlusCPWD (CHAR *cl, UBYTE srcId);
161 EXTERN T_ATI_RSLT setatPercentSECP (CHAR *cl, UBYTE srcId);
162 EXTERN T_ATI_RSLT setatPercentSECS (CHAR *cl, UBYTE srcId);
163 EXTERN T_ATI_RSLT quetatPercentSECS (CHAR *cl, UBYTE srcId);
164 EXTERN T_ATI_RSLT setatPlusCREG (CHAR *cl, UBYTE srcId);
165 EXTERN T_ATI_RSLT queatPlusCREG (CHAR *cl, UBYTE srcId);
166 GLOBAL T_ATI_RSLT setatPercentCREG (char *cl, UBYTE srcId);
167 GLOBAL T_ATI_RSLT queatPercentCREG (char *cl, UBYTE srcId);
168 EXTERN T_ATI_RSLT atPlusCRES (CHAR *cl, UBYTE srcId);
169 EXTERN T_ATI_RSLT tesatPlusCRES (CHAR *cl, UBYTE srcId);
170 EXTERN T_ATI_RSLT queatPlusCRES (CHAR *cl, UBYTE srcId);
171 EXTERN T_ATI_RSLT setatPlusCRSL (CHAR *cl, UBYTE srcId);
172 EXTERN T_ATI_RSLT tesatPlusCRSL (CHAR *cl, UBYTE srcId);
173 EXTERN T_ATI_RSLT queatPlusCRSL (CHAR *cl, UBYTE srcId);
174 EXTERN T_ATI_RSLT setatPlusCCUG (CHAR *cl, UBYTE srcId);
175 EXTERN T_ATI_RSLT queatPlusCCUG (CHAR *cl, UBYTE srcId);
176 EXTERN T_ATI_RSLT setatPlusCTFR (CHAR *cl, UBYTE srcId);
177 EXTERN T_ATI_RSLT setatPlusCCFC (CHAR *cl, UBYTE srcId);
178 EXTERN T_ATI_RSLT setatPlusCCWA (CHAR *cl, UBYTE srcId);
179 EXTERN T_ATI_RSLT queatPlusCCWA (CHAR *cl, UBYTE srcId);
180 EXTERN T_ATI_RSLT setatPlusCR (CHAR *cl, UBYTE srcId);
181 EXTERN T_ATI_RSLT setatPlusCRC (CHAR *cl, UBYTE srcId);
182 EXTERN T_ATI_RSLT queatPlusCR (CHAR *cl, UBYTE srcId);
183 EXTERN T_ATI_RSLT queatPlusCRC (CHAR *cl, UBYTE srcId);
184 EXTERN T_ATI_RSLT setatPlusCBST (CHAR *cl, UBYTE srcId);
185 EXTERN T_ATI_RSLT queatPlusCBST (CHAR *cl, UBYTE srcId);
186 EXTERN T_ATI_RSLT setatPlus_PercentCHLD(char *cl, UBYTE srcId, T_ACI_CHLD_CMD cmdType);
187 EXTERN T_ATI_RSLT setatPlusCHLD (CHAR *cl, UBYTE srcId);
188 EXTERN T_ATI_RSLT setatPercentCHLD (CHAR *cl, UBYTE srcId);
189 EXTERN T_ATI_RSLT atPlusCEER (CHAR *cl, UBYTE srcId);
190 EXTERN T_ATI_RSLT atPercentCSSD (CHAR *cl, UBYTE srcId);
191 EXTERN T_ATI_RSLT setatPlusCSSN (CHAR *cl, UBYTE srcId);
192 EXTERN T_ATI_RSLT queatPlusCSSN (CHAR *cl, UBYTE srcId);
193 EXTERN T_ATI_RSLT setatPercentCSSN (CHAR *cl, UBYTE srcId);
194 EXTERN T_ATI_RSLT queatPercentCSSN (CHAR *cl, UBYTE srcId);
195 EXTERN T_ATI_RSLT setatPlusCUSD (CHAR *cl, UBYTE srcId);
196 EXTERN T_ATI_RSLT queatPlusCUSD (CHAR *cl, UBYTE srcId);
197 EXTERN T_ATI_RSLT setatPlusCSNS (CHAR *cl, UBYTE srcId);
198 EXTERN T_ATI_RSLT queatPlusCSNS (CHAR *cl, UBYTE srcId);
199 EXTERN T_ATI_RSLT setatPlusWS46 (CHAR *cl, UBYTE srcId);
200 EXTERN T_ATI_RSLT queatPlusWS46 (CHAR *cl, UBYTE srcId);
201 EXTERN T_ATI_RSLT setatPlusCIMI(char *cl, UBYTE srcId);
202 EXTERN T_ATI_RSLT setatPlusCLCC(char *cl, UBYTE srcId);
203 EXTERN T_ATI_RSLT setatPercentCLCC(char *cl, UBYTE srcId);
204 EXTERN T_ATI_RSLT setatPercentDBGINFO(char *cl, UBYTE srcId);
205 EXTERN T_ATI_RSLT setatPlusCSQ (CHAR *cl, UBYTE srcId);
206 EXTERN T_ATI_RSLT tesatPlusCSQ (CHAR *cl, UBYTE srcId);
207
208 EXTERN T_ATI_RSLT setatPercentCSQ (CHAR *cl, UBYTE srcId);
209 EXTERN T_ATI_RSLT queatPercentCSQ (CHAR *cl, UBYTE srcId);
210 EXTERN T_ATI_RSLT tesatPercentCSQ (CHAR *cl, UBYTE srcId);
211
212 #ifdef SIM_PERS
213 /*For %MEPD -for querying ME Personalisation Data... Added on 11/03/2005*/
214 EXTERN T_ATI_RSLT setatPercentMEPD(CHAR *cl, UBYTE srcId);
215 #endif
216
217 EXTERN T_ATI_RSLT atPlusCBC (CHAR *cl, UBYTE srcId);
218 EXTERN T_ATI_RSLT setatPlusCMUT (CHAR *cl, UBYTE srcId);
219 EXTERN T_ATI_RSLT tesatPlusCMUT (CHAR *cl, UBYTE srcId);
220 EXTERN T_ATI_RSLT queatPlusCMUT (CHAR *cl, UBYTE srcId);
221 EXTERN T_ATI_RSLT setatPlusCNUM (CHAR *cl, UBYTE srcId);
222 EXTERN T_ATI_RSLT setatPlusCRSM (CHAR *cl, UBYTE srcId);
223 EXTERN T_ATI_RSLT setatPlusCSIM (CHAR *cl, UBYTE srcId);
224 EXTERN T_ATI_RSLT queatPercentATR ( CHAR *cl, UBYTE srcId );
225 EXTERN T_ATI_RSLT atPlusCSMS (CHAR *cl, UBYTE srcId);
226 EXTERN T_ATI_RSLT tesatPlusCSMS (CHAR *cl, UBYTE srcId);
227 EXTERN T_ATI_RSLT queatPlusCSMS (CHAR *cl, UBYTE srcId);
228 EXTERN T_ATI_RSLT atPlusCPMS (CHAR *cl, UBYTE srcId);
229 EXTERN T_ATI_RSLT tesatPlusCPMS (CHAR *cl, UBYTE srcId);
230 EXTERN T_ATI_RSLT queatPlusCPMS (CHAR *cl, UBYTE srcId);
231 EXTERN T_ATI_RSLT atPlusCMGF (CHAR *cl, UBYTE srcId);
232 #if defined FF_MMI_RIV
233 EXTERN T_ATI_RSLT setatPercentSMBS (CHAR *cl, UBYTE srcId);
234 EXTERN T_ATI_RSLT queatPercentSMBS (CHAR *cl, UBYTE srcId);
235 #endif /* FF_MMI_RIV */
236 EXTERN T_ATI_RSLT tesatPlusCMGF (CHAR *cl, UBYTE srcId);
237 EXTERN T_ATI_RSLT queatPlusCMGF (CHAR *cl, UBYTE srcId);
238 EXTERN T_ATI_RSLT atPlusCSCA (CHAR *cl, UBYTE srcId);
239 EXTERN T_ATI_RSLT tesatPlusCSCA (CHAR *cl, UBYTE srcId);
240 EXTERN T_ATI_RSLT queatPlusCSCA (CHAR *cl, UBYTE srcId);
241 EXTERN T_ATI_RSLT atPlusCSDH (CHAR *cl, UBYTE srcId);
242 EXTERN T_ATI_RSLT tesatPlusCSDH (CHAR *cl, UBYTE srcId);
243 EXTERN T_ATI_RSLT atPlusCSMP (CHAR *cl, UBYTE srcId);
244 EXTERN T_ATI_RSLT tesatPlusCSMP (CHAR *cl, UBYTE srcId);
245 EXTERN T_ATI_RSLT queatPlusCSMP (CHAR *cl, UBYTE srcId);
246 EXTERN T_ATI_RSLT setatPlusCSDH (CHAR *cl, UBYTE srcId);
247 EXTERN T_ATI_RSLT queatPlusCSDH (CHAR *cl, UBYTE srcId);
248 EXTERN T_ATI_RSLT setatPlusCSCS (CHAR *cl, UBYTE srcId);
249 EXTERN T_ATI_RSLT queatPlusCSCS (CHAR *cl, UBYTE srcId);
250 EXTERN T_ATI_RSLT atPlusCSCB (CHAR *cl, UBYTE srcId);
251 EXTERN T_ATI_RSLT queatPlusCSCB (CHAR *cl, UBYTE srcId);
252 #ifdef FF_HOMEZONE
253 EXTERN T_ATI_RSLT setatPercentCBHZ (CHAR *cl, UBYTE srcId);
254 EXTERN T_ATI_RSLT tesatPercentCBHZ (CHAR *cl, UBYTE srcId);
255 EXTERN T_ATI_RSLT queatPercentCBHZ (CHAR *cl, UBYTE srcId);
256 #endif /* FF_HOMEZONE */
257 EXTERN T_ATI_RSLT atPlusCMGR (CHAR *cl, UBYTE srcId);
258 EXTERN T_ATI_RSLT tesatPlusCMGR (CHAR *cl, UBYTE srcId);
259 EXTERN T_ATI_RSLT queatPlusCMGR (CHAR *cl, UBYTE srcId);
260 EXTERN T_ATI_RSLT atPlusCMSS (CHAR *cl, UBYTE srcId);
261 EXTERN T_ATI_RSLT setatPlusCMGD (char *cl, UBYTE srcId);
262 EXTERN T_ATI_RSLT atPlusCNMI (CHAR *cl, UBYTE srcId);
263 EXTERN T_ATI_RSLT tesatPlusCNMI (CHAR *cl, UBYTE srcId);
264 EXTERN T_ATI_RSLT queatPlusCNMI (CHAR *cl, UBYTE srcId);
265 EXTERN T_ATI_RSLT setatPercentCPRSM (CHAR *cl, UBYTE srcId);
266 EXTERN T_ATI_RSLT queatPercentCPRSM (CHAR *cl, UBYTE srcId);
267 EXTERN T_ATI_RSLT setatPlusCMEE (CHAR *cl, UBYTE srcId);
268 EXTERN T_ATI_RSLT queatPlusCMEE (CHAR *cl, UBYTE srcId);
269 EXTERN T_ATI_RSLT setatPlusCPBS (CHAR *cl, UBYTE srcId);
270 EXTERN T_ATI_RSLT queatPlusCPBS (CHAR *cl, UBYTE srcId);
271
272 EXTERN T_ATI_RSLT setatPercentPBCF (CHAR *cl, UBYTE srcId);
273 EXTERN T_ATI_RSLT queatPercentPBCF (CHAR *cl, UBYTE srcId);
274
275 EXTERN T_ATI_RSLT queatPercentCPBS (CHAR *cl, UBYTE srcId);
276 EXTERN T_ATI_RSLT setatPlusCPBW (CHAR *cl, UBYTE srcId);
277 EXTERN T_ATI_RSLT tesatPlusCPBW (CHAR *cl, UBYTE srcId);
278 EXTERN T_ATI_RSLT setatPlusCPBR (CHAR *cl, UBYTE srcId);
279 EXTERN T_ATI_RSLT tesatPlusCPBR (CHAR *cl, UBYTE srcId);
280 EXTERN T_ATI_RSLT setatPlusCPBF (CHAR *cl, UBYTE srcId);
281 EXTERN T_ATI_RSLT tesatPlusCPBF (CHAR *cl, UBYTE srcId);
282
283 EXTERN T_ATI_RSLT setatPlusCSVM (CHAR *cl, UBYTE srcId);
284 EXTERN T_ATI_RSLT queatPlusCSVM (CHAR *cl, UBYTE srcId);
285
286 EXTERN T_ATI_RSLT setatPlusCLAN (CHAR *cl, UBYTE srcId);
287 EXTERN T_ATI_RSLT queatPlusCLAN (CHAR *cl, UBYTE srcId);
288 EXTERN T_ATI_RSLT tesatPlusCLAN (CHAR *cl, UBYTE srcId);
289
290 EXTERN T_ATI_RSLT setatPlusVTS (CHAR *cl, UBYTE srcId);
291 EXTERN T_ATI_RSLT setatPercentVTS (CHAR *cl, UBYTE srcId);
292 EXTERN T_ATI_RSLT atPercentTEST (CHAR *cl, UBYTE srcId);
293 EXTERN T_ATI_RSLT setatPercentNRG (CHAR *cl, UBYTE srcId);
294 EXTERN T_ATI_RSLT queatPercentNRG (CHAR *cl, UBYTE srcId);
295 EXTERN T_ATI_RSLT tesatPercentNRG (CHAR *cl, UBYTE srcId);
296 EXTERN T_ATI_RSLT atAndF (CHAR *cl, UBYTE srcId);
297 EXTERN T_ATI_RSLT atAndC (CHAR *cl, UBYTE srcId);
298 EXTERN T_ATI_RSLT atAndD (CHAR *cl, UBYTE srcId);
299 EXTERN T_ATI_RSLT atAndK (CHAR *cl, UBYTE srcId);
300 EXTERN T_ATI_RSLT atPlusGCAP (CHAR *cl, UBYTE srcId);
301 EXTERN T_ATI_RSLT setatPlusIPR (CHAR *cl, UBYTE srcId);
302 EXTERN T_ATI_RSLT queatPlusIPR (CHAR *cl, UBYTE srcId);
303 EXTERN T_ATI_RSLT setatPlusICF (CHAR *cl, UBYTE srcId);
304 EXTERN T_ATI_RSLT queatPlusICF (CHAR *cl, UBYTE srcId);
305 EXTERN T_ATI_RSLT setatPlusIFC (CHAR *cl, UBYTE srcId);
306 EXTERN T_ATI_RSLT queatPlusIFC (CHAR *cl, UBYTE srcId);
307 EXTERN T_ATI_RSLT setatPlusFLO (CHAR *cl, UBYTE srcId);
308 EXTERN T_ATI_RSLT queatPlusFLO (CHAR *cl, UBYTE srcId);
309 EXTERN T_ATI_RSLT setatPlusILRR (CHAR *cl, UBYTE srcId);
310 EXTERN T_ATI_RSLT queatPlusILRR (CHAR *cl, UBYTE srcId);
311 /* AT commands for DTI managment */
312 #if defined (DTI)
313 EXTERN T_ATI_RSLT setatPercentDATA ( char *cl, UBYTE srcId );
314 EXTERN T_ATI_RSLT queatPercentDATA ( char *cl, UBYTE srcId );
315 EXTERN T_ATI_RSLT setatPercentDINF ( char *cl, UBYTE srcId );
316 #endif
317 /* trace function */
318 #ifdef FF_TRACE_OVER_MTST
319 EXTERN T_ATI_RSLT setatPercentMTST (CHAR *cl, UBYTE srcId );
320 #endif /* FF_TRACE_OVER_MTST */
321
322 EXTERN T_ATI_RSLT setatPlusCMUX (char *cl, UBYTE srcId);
323 EXTERN T_ATI_RSLT tesatPlusCMUX (char *cl, UBYTE srcId);
324 EXTERN T_ATI_RSLT queatPlusCMUX (char *cl, UBYTE srcId);
325 EXTERN T_ATI_RSLT setatPercentCUNS(char *cl, UBYTE srcId);
326 EXTERN T_ATI_RSLT queatPercentCUNS(char *cl, UBYTE srcId);
327
328 //-- Advice of Charge Commands --
329 EXTERN T_ATI_RSLT setatPlusCAOC (CHAR *cl, UBYTE srcId);
330 EXTERN T_ATI_RSLT queatPlusCAOC (CHAR *cl, UBYTE srcId);
331 EXTERN T_ATI_RSLT setatPlusCACM (CHAR *cl, UBYTE srcId);
332 EXTERN T_ATI_RSLT queatPlusCACM (CHAR *cl, UBYTE srcId);
333 EXTERN T_ATI_RSLT setatPlusCAMM (CHAR *cl, UBYTE srcId);
334 EXTERN T_ATI_RSLT queatPlusCAMM (CHAR *cl, UBYTE srcId);
335 EXTERN T_ATI_RSLT setatPlusCPUC (CHAR *cl, UBYTE srcId);
336 EXTERN T_ATI_RSLT queatPlusCPUC (CHAR *cl, UBYTE srcId);
337 EXTERN T_ATI_RSLT atPercentCACM (CHAR *cl, UBYTE srcId);
338 EXTERN T_ATI_RSLT atPercentCAOC (CHAR *cl, UBYTE srcId);
339 EXTERN T_ATI_RSLT atPercentCTV (CHAR *cl, UBYTE srcId);
340 EXTERN T_ATI_RSLT atPercentCOLR (CHAR *cl, UBYTE srcId);
341 EXTERN T_ATI_RSLT setatPercentCPI (CHAR *cl, UBYTE srcId);
342 EXTERN T_ATI_RSLT queatPercentCPI (CHAR *cl, UBYTE srcId);
343 EXTERN T_ATI_RSLT setatPercentCTTY (CHAR *cl, UBYTE srcId);
344 EXTERN T_ATI_RSLT queatPercentCTTY (CHAR *cl, UBYTE srcId);
345 EXTERN T_ATI_RSLT atA (CHAR *cl, UBYTE srcId);
346 EXTERN T_ATI_RSLT atBW (CHAR *cl, UBYTE srcId);
347 EXTERN T_ATI_RSLT atD (CHAR *cl, UBYTE srcId);
348 EXTERN T_ATI_RSLT atEFLMQVX (CHAR *cl, UBYTE srcId);
349 EXTERN T_ATI_RSLT atH (CHAR *cl, UBYTE srcId);
350 EXTERN T_ATI_RSLT atI (CHAR *cl, UBYTE srcId);
351 EXTERN T_ATI_RSLT atS (CHAR *cl, UBYTE srcId);
352 EXTERN T_ATI_RSLT atTP(CHAR *cl, UBYTE srcId);
353 EXTERN T_ATI_RSLT atZ (CHAR *cl, UBYTE srcId);
354 EXTERN T_ATI_RSLT atAndW (char *cl, UBYTE srcId);
355
356 /*
357 * AT commands for location service
358 */
359 #if defined FF_EOTD
360 EXTERN T_ATI_RSLT setatPlusCLSA (char *cl, UBYTE srcId);
361 EXTERN T_ATI_RSLT queatPlusCLSA (char *cl, UBYTE srcId);
362 EXTERN T_ATI_RSLT setatPlusCLOM (char *cl, UBYTE srcId);
363 EXTERN T_ATI_RSLT queatPlusCLOM (char *cl, UBYTE srcId);
364 EXTERN T_ATI_RSLT setatPlusCLPS (char *cl, UBYTE srcId);
365 EXTERN T_ATI_RSLT queatPlusCLPS (char *cl, UBYTE srcId);
366 EXTERN T_ATI_RSLT setatPlusCLSR (char *cl, UBYTE srcId);
367 #endif /* FF_EOTD */
368
369 #ifdef FAX_AND_DATA
370 EXTERN T_ATI_RSLT atO (CHAR *cl, UBYTE srcId);
371 EXTERN T_ATI_RSLT setatPlusDS (CHAR *cl, UBYTE srcId);
372 EXTERN T_ATI_RSLT queatPlusDS (CHAR *cl, UBYTE srcId);
373 EXTERN T_ATI_RSLT setatPlusDR (CHAR *cl, UBYTE srcId);
374 EXTERN T_ATI_RSLT queatPlusDR (CHAR *cl, UBYTE srcId);
375 EXTERN T_ATI_RSLT setatPlusCRLP (CHAR *cl, UBYTE srcId);
376 EXTERN T_ATI_RSLT queatPlusCRLP (CHAR *cl, UBYTE srcId);
377
378 //--- Parameter Commands--------
379
380 #ifdef FF_FAX
381
382 EXTERN T_ATI_RSLT setatPlusFAP (CHAR *cl, UBYTE srcId);
383 EXTERN T_ATI_RSLT queatPlusFAP (CHAR *cl, UBYTE srcId);
384 EXTERN T_ATI_RSLT queatPlusFBS (CHAR *cl, UBYTE srcId);
385 EXTERN T_ATI_RSLT setatPlusFBU (CHAR *cl, UBYTE srcId);
386 EXTERN T_ATI_RSLT queatPlusFBU (CHAR *cl, UBYTE srcId);
387 EXTERN T_ATI_RSLT setatPlusFBO (CHAR *cl, UBYTE srcId);
388 EXTERN T_ATI_RSLT queatPlusFBO (CHAR *cl, UBYTE srcId);
389 EXTERN T_ATI_RSLT setatPlusFCC (CHAR *cl, UBYTE srcId);
390 EXTERN T_ATI_RSLT queatPlusFCC (CHAR *cl, UBYTE srcId);
391 EXTERN T_ATI_RSLT setatPlusFCR (CHAR *cl, UBYTE srcId);
392 EXTERN T_ATI_RSLT queatPlusFCR (CHAR *cl, UBYTE srcId);
393 EXTERN T_ATI_RSLT queatPlusFCS (CHAR *cl, UBYTE srcId);
394 EXTERN T_ATI_RSLT setatPlusFCT (CHAR *cl, UBYTE srcId);
395 EXTERN T_ATI_RSLT queatPlusFCT (CHAR *cl, UBYTE srcId);
396 EXTERN T_ATI_RSLT setatPlusFCLASS (CHAR *cl, UBYTE srcId);
397 EXTERN T_ATI_RSLT queatPlusFCLASS (CHAR *cl, UBYTE srcId);
398 EXTERN T_ATI_RSLT setatPlusFCQ (CHAR *cl, UBYTE srcId);
399 EXTERN T_ATI_RSLT queatPlusFCQ (CHAR *cl, UBYTE srcId);
400 EXTERN T_ATI_RSLT setatPlusFDR (CHAR *cl, UBYTE srcId);
401 EXTERN T_ATI_RSLT setatPlusFDT (CHAR *cl, UBYTE srcId);
402
403 EXTERN T_ATI_RSLT setatPlusFEA (CHAR *cl, UBYTE srcId);
404 EXTERN T_ATI_RSLT queatPlusFEA (CHAR *cl, UBYTE srcId);
405 EXTERN T_ATI_RSLT setatPlusFFC (CHAR *cl, UBYTE srcId);
406 EXTERN T_ATI_RSLT queatPlusFFC (CHAR *cl, UBYTE srcId);
407 EXTERN T_ATI_RSLT queatPlusFHS (CHAR *cl, UBYTE srcId);
408 EXTERN T_ATI_RSLT setatPlusFIT (CHAR *cl, UBYTE srcId);
409 EXTERN T_ATI_RSLT queatPlusFIT (CHAR *cl, UBYTE srcId);
410 EXTERN T_ATI_RSLT setatPlusFIE (CHAR *cl, UBYTE srcId);
411 EXTERN T_ATI_RSLT queatPlusFIE (CHAR *cl, UBYTE srcId);
412 EXTERN T_ATI_RSLT setatPlusFIP (CHAR *cl, UBYTE srcId);
413 EXTERN T_ATI_RSLT setatPlusFIS (CHAR *cl, UBYTE srcId);
414 EXTERN T_ATI_RSLT queatPlusFIS (CHAR *cl, UBYTE srcId);
415 EXTERN T_ATI_RSLT setatPlusFKS (CHAR *cl, UBYTE srcId);
416
417 EXTERN T_ATI_RSLT atPlusFMI (CHAR *cl, UBYTE srcId);
418 EXTERN T_ATI_RSLT atPlusFMM (CHAR *cl, UBYTE srcId);
419 EXTERN T_ATI_RSLT atPlusFMR (CHAR *cl, UBYTE srcId);
420 EXTERN T_ATI_RSLT setatPlusFMS (CHAR *cl, UBYTE srcId);
421 EXTERN T_ATI_RSLT queatPlusFMS (CHAR *cl, UBYTE srcId);
422
423 EXTERN T_ATI_RSLT setatPlusFLI (CHAR *cl, UBYTE srcId);
424 EXTERN T_ATI_RSLT queatPlusFLI (CHAR *cl, UBYTE srcId);
425 EXTERN T_ATI_RSLT setatPlusFLP (CHAR *cl, UBYTE srcId);
426 EXTERN T_ATI_RSLT queatPlusFLP (CHAR *cl, UBYTE srcId);
427 EXTERN T_ATI_RSLT setatPlusFND (CHAR *cl, UBYTE srcId);
428 EXTERN T_ATI_RSLT queatPlusFND (CHAR *cl, UBYTE srcId);
429 EXTERN T_ATI_RSLT setatPlusFNR (CHAR *cl, UBYTE srcId);
430 EXTERN T_ATI_RSLT queatPlusFNR (CHAR *cl, UBYTE srcId);
431 EXTERN T_ATI_RSLT setatPlusFNS (CHAR *cl, UBYTE srcId);
432 EXTERN T_ATI_RSLT queatPlusFNS (CHAR *cl, UBYTE srcId);
433
434 EXTERN T_ATI_RSLT setatPlusFPA (CHAR *cl, UBYTE srcId);
435 EXTERN T_ATI_RSLT queatPlusFPA (CHAR *cl, UBYTE srcId);
436 EXTERN T_ATI_RSLT setatPlusFPI (CHAR *cl, UBYTE srcId);
437 EXTERN T_ATI_RSLT queatPlusFPI (CHAR *cl, UBYTE srcId);
438 EXTERN T_ATI_RSLT setatPlusFPS (CHAR *cl, UBYTE srcId);
439 EXTERN T_ATI_RSLT queatPlusFPS (CHAR *cl, UBYTE srcId);
440 EXTERN T_ATI_RSLT setatPlusFPW (CHAR *cl, UBYTE srcId);
441 EXTERN T_ATI_RSLT queatPlusFPW (CHAR *cl, UBYTE srcId);
442 EXTERN T_ATI_RSLT setatPlusFRQ (CHAR *cl, UBYTE srcId);
443 EXTERN T_ATI_RSLT queatPlusFRQ (CHAR *cl, UBYTE srcId);
444 EXTERN T_ATI_RSLT setatPlusFSA (CHAR *cl, UBYTE srcId);
445 EXTERN T_ATI_RSLT queatPlusFSA (CHAR *cl, UBYTE srcId);
446 EXTERN T_ATI_RSLT setatPlusFSP (CHAR *cl, UBYTE srcId);
447 EXTERN T_ATI_RSLT queatPlusFSP (CHAR *cl, UBYTE srcId);
448
449 #endif /* FF_FAX */
450
451 #endif /* FAX_AND_DATA */
452
453 #ifdef SIM_TOOLKIT
454
455 //-- Action Commands-------------
456
457 EXTERN T_ATI_RSLT atPercentSATE (CHAR *cl, UBYTE srcId);
458 EXTERN T_ATI_RSLT setatPercentSATC (CHAR *cl, UBYTE srcId);
459 EXTERN T_ATI_RSLT tesatPercentSATC (CHAR *cl, UBYTE srcId);
460 EXTERN T_ATI_RSLT queatPercentSATC (CHAR *cl, UBYTE srcId);
461 EXTERN T_ATI_RSLT atPercentSATR (CHAR *cl, UBYTE srcId);
462 EXTERN T_ATI_RSLT atPercentSATT (CHAR *cl, UBYTE srcId);
463 EXTERN T_ATI_RSLT setatPercentSIMEF (CHAR *cl, UBYTE srcId);
464 EXTERN T_ATI_RSLT queatPercentSIMEF (CHAR *cl, UBYTE srcId);
465 EXTERN T_ATI_RSLT setatPercentEFRSLT (CHAR *cl, UBYTE srcId);
466 #endif /* SIM_TOOLKIT */
467
468 EXTERN T_ATI_RSLT atPlusCMGS (CHAR *cl, UBYTE srcId);
469 EXTERN T_ATI_RSLT tesatPlusCMGS (CHAR *cl, UBYTE srcId);
470 EXTERN T_ATI_RSLT queatPlusCMGS (CHAR *cl, UBYTE srcId);
471 EXTERN T_ATI_RSLT atPlusCMGW (CHAR *cl, UBYTE srcId);
472 EXTERN T_ATI_RSLT tesatPlusCMGW (CHAR *cl, UBYTE srcId);
473 EXTERN T_ATI_RSLT queatPlusCMGW (CHAR *cl, UBYTE srcId);
474 EXTERN T_ATI_RSLT atPlusCMGC (CHAR *cl, UBYTE srcId);
475 EXTERN T_ATI_RSLT atPlusCNMA (CHAR *cl, UBYTE srcId);
476 EXTERN T_ATI_RSLT tesatPlusCNMA (CHAR *cl, UBYTE srcId);
477 EXTERN T_ATI_RSLT queatPlusCNMA (CHAR *cl, UBYTE srcId);
478 EXTERN T_ATI_RSLT tesatPlusCMGC (CHAR *cl, UBYTE srcId);
479
480 EXTERN T_ATI_RSLT atPercentVER (char* cl, UBYTE srcId);
481 EXTERN T_ATI_RSLT setatPercentCNAP(char *cl, UBYTE srcId);
482 EXTERN T_ATI_RSLT queatPercentCNAP(char *cl, UBYTE srcId);
483 EXTERN T_ATI_RSLT setatPercentALS ( char *cl, UBYTE srcId );
484 EXTERN T_ATI_RSLT tesatPercentALS ( char *cl, UBYTE srcId );
485 EXTERN T_ATI_RSLT queatPercentALS ( char *cl, UBYTE srcId );
486 EXTERN T_ATI_RSLT setatPercentBAND( char *cl, UBYTE srcId );
487 EXTERN T_ATI_RSLT tesatPercentBAND( char *cl, UBYTE srcId );
488 EXTERN T_ATI_RSLT queatPercentBAND( char *cl, UBYTE srcId );
489 EXTERN T_ATI_RSLT setatPercentCPRI( char *cl, UBYTE srcId );
490 EXTERN T_ATI_RSLT queatPercentCPRI( char *cl, UBYTE srcId );
491 EXTERN T_ATI_RSLT setatPlusCTZR( char *cl, UBYTE srcId );
492 EXTERN T_ATI_RSLT queatPlusCTZR( char *cl, UBYTE srcId );
493 EXTERN T_ATI_RSLT setatPlusCTZU( char *cl, UBYTE srcId );
494 EXTERN T_ATI_RSLT queatPlusCTZU( char *cl, UBYTE srcId );
495 EXTERN T_ATI_RSLT setatPlusCCLK (char *cl, UBYTE srcId );
496 EXTERN T_ATI_RSLT queatPlusCCLK (char *cl, UBYTE srcId );
497 EXTERN T_ATI_RSLT setatPercentCTZV( char *cl, UBYTE srcId );
498 EXTERN T_ATI_RSLT queatPercentCTZV( char *cl, UBYTE srcId );
499 EXTERN T_ATI_RSLT setatPercentCNIV( char *cl, UBYTE srcId );
500 EXTERN T_ATI_RSLT queatPercentCNIV( char *cl, UBYTE srcId );
501
502 EXTERN T_ATI_RSLT setatPercentDAR( char *cl, UBYTE srcId );
503
504 /* EXTERN T_ATI_RSLT queatPercentDAR( char *cl, UBYTE srcId ); */
505 EXTERN T_ATI_RSLT setatPercentCSCN( char *cl, UBYTE srcId );
506 EXTERN T_ATI_RSLT queatPercentCSCN( char *cl, UBYTE srcId );
507
508 #if defined(FF_WAP) || defined(FF_TCP_IP) || defined (FF_SAT_E)
509 EXTERN T_ATI_RSLT atPercentPPP (CHAR *cl, UBYTE srcId);
510 EXTERN T_ATI_RSLT queatPercentPPP (CHAR *cl, UBYTE srcId);
511 #endif /* defined(WAP) || defined(FF_TCP_IP) || defined (FF_SAT_E)*/
512
513 #if defined(FF_WAP) || defined (FF_SAT_E)
514 EXTERN T_ATI_RSLT atPercentWAP (CHAR *cl, UBYTE srcId);
515 #endif /* WAP or SAT E */
516
517 #ifdef GPRS
518 /*
519 * declaration of functions
520 * for GSM 07.07 version 6.4.0 Release 1997
521 */
522 EXTERN T_ATI_RSLT setatPlusCGDCONT (char *cl, UBYTE srcId);
523 EXTERN T_ATI_RSLT setatPlusCGQREQ (char *cl, UBYTE srcId);
524 EXTERN T_ATI_RSLT setatPlusCGQMIN (char *cl, UBYTE srcId);
525 EXTERN T_ATI_RSLT setatPlusCGATT (char *cl, UBYTE srcId);
526 EXTERN T_ATI_RSLT setatPlusCGACT (char *cl, UBYTE srcId);
527 EXTERN T_ATI_RSLT setatPlusCGDATA (char *cl, UBYTE srcId);
528 EXTERN T_ATI_RSLT setatPlusCGPADDR (char *cl, UBYTE srcId);
529 EXTERN T_ATI_RSLT setatPlusCGAUTO (char *cl, UBYTE srcId);
530 EXTERN T_ATI_RSLT setatPlusCGANS (char *cl, UBYTE srcId);
531 EXTERN T_ATI_RSLT setatPlusCGCLASS (char *cl, UBYTE srcId);
532 EXTERN T_ATI_RSLT setatPlusCGEREP (char *cl, UBYTE srcId);
533 EXTERN T_ATI_RSLT setatPlusCGREG (char *cl, UBYTE srcId);
534 EXTERN T_ATI_RSLT setatPlusCGSMS (char *cl, UBYTE srcId);
535 EXTERN T_ATI_RSLT setatPercentCGEREP (char *cl, UBYTE srcId);
536
537 EXTERN T_ATI_RSLT queatPlusCGDCONT (char *cl, UBYTE srcId);
538 EXTERN T_ATI_RSLT queatPlusCGQREQ (char *cl, UBYTE srcId);
539 EXTERN T_ATI_RSLT queatPlusCGQMIN (char *cl, UBYTE srcId);
540 EXTERN T_ATI_RSLT queatPlusCGATT (char *cl, UBYTE srcId);
541 EXTERN T_ATI_RSLT queatPlusCGACT (char *cl, UBYTE srcId);
542 EXTERN T_ATI_RSLT queatPlusCGAUTO (char *cl, UBYTE srcId);
543 EXTERN T_ATI_RSLT queatPlusCGCLASS (char *cl, UBYTE srcId);
544 EXTERN T_ATI_RSLT queatPlusCGEREP (char *cl, UBYTE srcId);
545 EXTERN T_ATI_RSLT queatPlusCGREG (char *cl, UBYTE srcId);
546 EXTERN T_ATI_RSLT queatPlusCGSMS (char *cl, UBYTE srcId);
547 EXTERN T_ATI_RSLT queatPercentCGEREP (char *cl, UBYTE srcId);
548
549 EXTERN T_ATI_RSLT tesatPlusCGDCONT (char *cl, UBYTE srcId);
550 EXTERN T_ATI_RSLT tesatPlusCGPADDR (char *cl, UBYTE srcId);
551 EXTERN T_ATI_RSLT tesatPlusCGSMS (char *cl, UBYTE srcId);
552
553 EXTERN T_ATI_RSLT setatPercentCGAATT (char *cl, UBYTE srcId);
554 EXTERN T_ATI_RSLT queatPercentCGAATT (char *cl, UBYTE srcId);
555
556 EXTERN T_ATI_RSLT setatPercentSNCNT (char *cl, UBYTE srcId);
557 EXTERN T_ATI_RSLT queatPercentSNCNT (char *cl, UBYTE srcId);
558
559 EXTERN T_ATI_RSLT setatPercentCGMM (char *cl, UBYTE srcId);
560
561 EXTERN T_ATI_RSLT setatPercentCGPCO (char *cl, UBYTE srcId);
562
563 EXTERN T_ATI_RSLT setatPercentCGPPP (CHAR *cl, UBYTE srcId);
564 EXTERN T_ATI_RSLT queatPercentCGPPP (CHAR *cl, UBYTE srcId);
565
566 EXTERN T_ATI_RSLT setatPercentCGREG (CHAR *cl, UBYTE srcId);
567 EXTERN T_ATI_RSLT queatPercentCGREG (CHAR *cl, UBYTE srcId);
568
569 EXTERN T_ATI_RSLT setatPercentCGCLASS (CHAR *cl, UBYTE srcId);
570 EXTERN T_ATI_RSLT queatPercentCGCLASS (CHAR *cl, UBYTE srcId);
571 EXTERN T_ATI_RSLT setatPercentCREG (CHAR *cl, UBYTE srcId);
572 EXTERN T_ATI_RSLT queatPercentCREG (CHAR *cl, UBYTE srcId);
573 EXTERN T_ATI_RSLT setatPercentCREG (CHAR *cl, UBYTE srcId);
574 EXTERN T_ATI_RSLT queatPercentCREG (CHAR *cl, UBYTE srcId);
575 #endif /* GPRS */
576
577 #ifdef FF_EM_MODE
578 /*
579 AT commands for the engineering mode
580 */
581 EXTERN T_ATI_RSLT setatPercentEM (char *cl, UBYTE srcId);
582 EXTERN T_ATI_RSLT setatPercentEMET (char *cl, UBYTE srcId);
583 EXTERN T_ATI_RSLT setatPercentEMETS(char *cl, UBYTE srcId);
584 #endif /* FF_EM_MODE */
585
586 #ifdef FF_CPHS
587 EXTERN T_ATI_RSLT setatPercentCPHS(CHAR *cl, UBYTE srcId);
588 EXTERN T_ATI_RSLT queatPercentCPHS(CHAR *cl, UBYTE srcId);
589
590 EXTERN T_ATI_RSLT setatPercentCPNUMS(CHAR *cl, UBYTE srcId);
591 EXTERN T_ATI_RSLT tesatPercentCPNUMS(CHAR *cl, UBYTE srcId);
592
593 EXTERN T_ATI_RSLT setatPercentCPALS(CHAR *cl, UBYTE srcId);
594 EXTERN T_ATI_RSLT queatPercentCPALS(CHAR *cl, UBYTE srcId);
595 EXTERN T_ATI_RSLT tesatPercentCPALS(CHAR *cl, UBYTE srcId);
596
597 EXTERN T_ATI_RSLT setatPercentCPVWI(CHAR *cl, UBYTE srcId);
598
599 EXTERN T_ATI_RSLT queatPercentCPOPN(CHAR *cl, UBYTE srcId);
600
601 EXTERN T_ATI_RSLT setatPercentCPINF(CHAR *cl, UBYTE srcId);
602 EXTERN T_ATI_RSLT queatPercentCPINF(CHAR *cl, UBYTE srcId);
603
604 EXTERN T_ATI_RSLT setatPercentCPMB(CHAR *cl, UBYTE srcId);
605 EXTERN T_ATI_RSLT queatPercentCPMB(CHAR *cl, UBYTE srcId);
606
607 EXTERN T_ATI_RSLT setatPercentCPMBW(CHAR *cl, UBYTE srcId);
608 EXTERN T_ATI_RSLT tesatPercentCPMBW(CHAR *cl, UBYTE srcId);
609
610 EXTERN T_ATI_RSLT setatPercentCPCFU(CHAR *cl, UBYTE srcId);
611 #endif /* FF_CPHS */
612
613 EXTERN T_ATI_RSLT setatPercentCHPL ( char *cl, UBYTE srcId );
614 EXTERN T_ATI_RSLT setatPercentPVRF( char *cl, UBYTE srcId );
615 EXTERN T_ATI_RSLT queatPercentPVRF( char *cl, UBYTE srcId );
616 EXTERN T_ATI_RSLT setatPercentCWUP( char *cl, UBYTE srcId );
617
618 EXTERN T_ATI_RSLT queatPercentSIMIND( char *cl, UBYTE srcId );
619 EXTERN T_ATI_RSLT setatPercentSIMIND( char *cl, UBYTE srcId );
620
621 LOCAL T_ATI_RSLT test_gen(CHAR *cl, UBYTE srcId);
622 #ifdef MFW
623 /* MMI TEST */
624 EXTERN T_ATI_RSLT setatPercentMMITEST (char *cl, UBYTE srcId);
625 #endif
626
627 /* AT commands for redialling */
628 EXTERN T_ATI_RSLT setatPercentRDL (char* cl, UBYTE srcId);
629 EXTERN T_ATI_RSLT queatPercentRDL (char* cl, UBYTE srcId);
630 EXTERN T_ATI_RSLT setatPercentRDLB (char* cl, UBYTE srcId);
631 EXTERN T_ATI_RSLT queatPercentRDLB (char* cl, UBYTE srcId);
632
633 /* AT command for reporting States*/
634 EXTERN T_ATI_RSLT setatPercentCSTAT (char* cl, UBYTE srcId);
635 EXTERN T_ATI_RSLT queatPercentCSTAT (char* cl, UBYTE srcId);
636
637 EXTERN T_ATI_RSLT setatPlusCIND (char *cl, UBYTE srcId);
638 EXTERN T_ATI_RSLT queatPlusCIND (char *cl, UBYTE srcId);
639 EXTERN T_ATI_RSLT setatPlusCMER (char *cl, UBYTE srcId);
640 EXTERN T_ATI_RSLT queatPlusCMER (char *cl, UBYTE srcId);
641 EXTERN T_ATI_RSLT setatPercentCUST (char* cl, UBYTE srcId);
642 EXTERN T_ATI_RSLT queatPercentCUST (char* cl, UBYTE srcId);
643 EXTERN T_ATI_RSLT setatPercentSATCC (char* cl, UBYTE srcId);
644 EXTERN T_ATI_RSLT queatPercentSATCC (char* cl, UBYTE srcId);
645
646 #ifdef FF_DUAL_SIM
647 EXTERN T_ATI_RSLT setatPercentSIM (char* cl, UBYTE srcId);
648 EXTERN T_ATI_RSLT queatPercentSIM (char* cl, UBYTE srcId);
649 #endif /*FF_DUAL_SIM*/
650
651 EXTERN T_ATI_RSLT setatPercentCUSCFG (char* cl, UBYTE srcId);
652 EXTERN T_ATI_RSLT setatPercentCUSDR (char* cl, UBYTE srcId);
653
654 EXTERN T_ATI_RSLT setatPlusCMMS (char* cl, UBYTE srcId);
655 EXTERN T_ATI_RSLT queatPlusCMMS (char* cl, UBYTE srcId);
656
657 EXTERN T_ATI_RSLT setatPercentSTDR ( char *cl, UBYTE srcId );
658 EXTERN T_ATI_RSLT setatPercentCMGMDU ( char *cl, UBYTE srcId );
659
660 EXTERN T_ATI_RSLT atPercentCMGL (CHAR *cl, UBYTE srcId);
661 EXTERN T_ATI_RSLT atPercentCMGR (CHAR *cl, UBYTE srcId);
662
663 EXTERN T_ATI_RSLT tesatPercentCMGL(CHAR *cl, UBYTE srcId);
664
665 /* FreeCalypso replicating Openmoko's additions */
666 EXTERN T_ATI_RSLT atAtST (CHAR *cl, UBYTE srcId);
667 EXTERN T_ATI_RSLT tesatAtST (CHAR *cl, UBYTE srcId);
668 EXTERN T_ATI_RSLT queatAtST (CHAR *cl, UBYTE srcId);
669 EXTERN T_ATI_RSLT atAtAUL (CHAR *cl, UBYTE srcId);
670 EXTERN T_ATI_RSLT tesatAtAUL (CHAR *cl, UBYTE srcId);
671 EXTERN T_ATI_RSLT queatAtAUL (CHAR *cl, UBYTE srcId);
672 EXTERN T_ATI_RSLT atAtPOFF (CHAR *cl, UBYTE srcId);
673 EXTERN T_ATI_RSLT atAtRST (CHAR *cl, UBYTE srcId);
674 EXTERN T_ATI_RSLT atAtSC (CHAR *cl, UBYTE srcId);
675 EXTERN T_ATI_RSLT atAtBAND (CHAR *cl, UBYTE srcId);
676
677 LOCAL const ATCommand_bas cmds_bas[] =
678 {
679 {"A", atA, 0, 0 },
680 {"B", atBW, 0, 0 },
681 { 0, 0, "&C", atAndC},
682 {"D", atD, "&D", atAndD},
683 {"E", atEFLMQVX, 0, 0 },
684 {"F", atEFLMQVX,"&F", atAndF},
685 { 0, 0, 0, 0 },
686 {"H", atH, 0, 0 },
687 {"I", atI, 0, 0 },
688 { 0, 0, 0, 0 },
689 { 0, 0, "&K", atAndK},
690 {"L", atEFLMQVX, 0, 0 },
691 {"M", atEFLMQVX, 0, 0 },
692 { 0, 0, 0, 0 },
693 #ifdef FAX_AND_DATA //Fax and Data Module only
694 {"O", atO, 0, 0 },
695 #else
696 { 0, 0, 0, 0 },
697 #endif
698 {"P", atTP, 0, 0 },
699 {"Q", atEFLMQVX, 0, 0 },
700 { 0, 0, 0, 0 },
701 {"S", atS, 0, 0 },
702 {"T", atTP, 0, 0 },
703 { 0, 0, 0, 0 },
704 {"V", atEFLMQVX, 0, 0 },
705 {"W", atBW, "&W", atAndW},
706 {"X", atEFLMQVX, 0, 0 },
707 { 0, 0, 0, 0 },
708 {"Z", atZ, 0, 0 }
709 };
710
711
712 #ifdef FAX_AND_DATA
713 #define FD_CMD(a,b,c,d,e,f) {a,b,c,d,e,f},
714 #ifdef V42BIS
715 #define V42_CMD(a,b,c,d,e,f) {a,b,c,d,e,f},
716 #else
717 #define V42_CMD(a,b,c,d,e,f)
718 #endif /* V42BIS */
719 #else
720 #define FD_CMD(a,b,c,d,e,f)
721 #define V42_CMD(a,b,c,d,e,f)
722 #endif /* FAX_AND_DATA */
723
724 #if defined (SIM_TOOLKIT)
725 #define SAT_CMD(a,b,c,d,e,f) {a,b,c,d,e,f},
726 #else
727 #define SAT_CMD(a,b,c,d,e,f)
728 #endif /* SIM_TOOLKIT */
729
730 #if defined (FF_WAP)
731 #define WAP_CMD(a,b,c,d,e,f) {a,b,c,d,e,f},
732 #else
733 #define WAP_CMD(a,b,c,d,e,f)
734 #endif /* WAP */
735
736 #if defined FF_EOTD
737 #define LOC_CMD(a,b,c,d,e,f) {a,b,c,d,e,f},
738 #else
739 #define LOC_CMD(a,b,c,d,e,f)
740 #endif
741
742 #ifdef GPRS
743 /* n.b. context is packet data equivalent of a cct switched call */
744 /* existing +H,+D,+S,+ABORT and +CFUNC are also affected*/
745 #define GPRS_CMD(a,b,c,d,e,f) {a,b,c,d,e,f},
746 #else
747 #define GPRS_CMD(a,b,c,d,e,f)
748 #endif /* GPRS */
749
750 #ifdef FF_EM_MODE
751 #define EM_CMD(a,b,c,d,e,f) {a,b,c,d,e,f},
752 #else
753 #define EM_CMD(a,b,c,d,e,f)
754 #endif /* FF_EM_MODE */
755
756 #ifdef FF_CPHS
757 #define CPHS_CMD(a,b,c,d,e,f) {a,b,c,d,e,f},
758 #else
759 #define CPHS_CMD(a,b,c,d,e,f)
760 #endif /* FF_CPHS */
761
762 #ifdef FF_TRACE_OVER_MTST
763 #define MTST_CMD(a,b,c,d,e,f) {a,b,c,d,e,f},
764 #else
765 #define MTST_CMD(a,b,c,d,e,f)
766 #endif /* FF_TRACE_OVER_MTST */
767
768 #ifdef FF_HOMEZONE
769 #define HZ_CMD(a,b,c,d,e,f) {a,b,c,d,e,f},
770 #else
771 #define HZ_CMD(a,b,c,d,e,f)
772 #endif /* FF_HOMEZONE */
773
774 #ifdef MFW
775 #define MFW_CMD(a,b,c,d,e,f) {a,b,c,d,e,f},
776 #else
777 #define MFW_CMD(a,b,c,d,e,f)
778 #endif /* MFW */
779
780 #ifdef FF_TTY
781 #define TTY_CMD(a,b,c,d,e,f) {a,b,c,d,e,f},
782 #else
783 #define TTY_CMD(a,b,c,d,e,f)
784 #endif /* FF_TTY */
785
786 #if defined FF_MMI_RIV
787 #define SMBS_CMD(a,b,c,d,e,f) {a,b,c,d,e,f},
788 #else
789 #define SMBS_CMD(a,b,c,d,e,f)
790 #endif /* FF_MMI_RIV */
791
792 #if defined (SMS_PDU_SUPPORT)
793 #define CMGF_TEST_OUTPUT "%s: (0,1)"
794 #else
795 #define CMGF_TEST_OUTPUT "%s: (1)"
796 #endif /* SMS_PDU_SUPPORT */
797
798 LOCAL const ATCommand cmds [] =
799 {
800 {NULL,0,0,0,0,0},
801 {"+CACM", AT_CMD_CACM, setatPlusCACM, test_gen, queatPlusCACM, 0},
802 {"+CAMM", AT_CMD_CAMM, setatPlusCAMM, test_gen, queatPlusCAMM, 0},
803 {"+CAOC", AT_CMD_CAOC, setatPlusCAOC, test_gen, queatPlusCAOC, "%s: (0-2)"},
804 {"+CBC", AT_CMD_CBC, atPlusCBC, test_gen, 0, "%s: (0-3),(0-100)"},
805 {"+CBST", AT_CMD_CBST, setatPlusCBST, test_gen, queatPlusCBST, "%s: (0-7,12,14,65,66,68,70,71,75),(0),(0-3)"},
806 {"+CCFC", AT_CMD_CCFC, setatPlusCCFC, test_gen, 0, "%s: (0-5)"},
807 {"+CCUG", AT_CMD_CCUG, setatPlusCCUG, test_gen, queatPlusCCUG, "%s: (0,1),(0-10),(0-3)"},
808 {"+CCWA", AT_CMD_CCWA, setatPlusCCWA, test_gen, queatPlusCCWA, "%s: (0,1)"},
809 {"+CCWE", AT_CMD_CCWE, setatPlusCCWE, test_gen, queatPlusCCWE, "%s: (0,1)"},
810 {"+CEER", AT_CMD_CEER, atPlusCEER, test_gen, 0, 0},
811 {"+CFUN", AT_CMD_CFUN, setatPlusCFUN, test_gen, queatPlusCFUN, "%s: (0,1,4),(0)"},
812 GPRS_CMD("+CGACT", AT_CMD_CGACT, setatPlusCGACT, test_gen, queatPlusCGACT, "%s: (0,1)") /* GPRS: context activation/deactivation */
813 GPRS_CMD("+CGANS", AT_CMD_CGANS, setatPlusCGANS, test_gen, 0, "%s: (0,1),(\"PPP\")") /* GPRS: answer NW context req */
814 GPRS_CMD("+CGATT", AT_CMD_CGATT, setatPlusCGATT, test_gen, queatPlusCGATT, "%s: (0,1)") /* GPRS: GPRS attach/detach */
815 GPRS_CMD("+CGAUTO", AT_CMD_CGAUTO, setatPlusCGAUTO, test_gen, queatPlusCGAUTO, "%s: (0-3)") /* GPRS: auto answer/modem comp control */
816 GPRS_CMD("+CGCLASS",AT_CMD_CGCLASS,setatPlusCGCLASS, test_gen, queatPlusCGCLASS, "%s: (\"B\",\"CG\",\"CC\")") /* GPRS: GPRS class change */
817 GPRS_CMD("+CGDATA", AT_CMD_CGDATA, setatPlusCGDATA, test_gen, 0, "%s: \"PPP\"") /* GPRS: data connect */
818 GPRS_CMD("+CGDCONT",AT_CMD_CGDCONT,setatPlusCGDCONT, tesatPlusCGDCONT,queatPlusCGDCONT, 0) /* GPRS: PDP context definition */
819 GPRS_CMD("+CGEREP", AT_CMD_CGEREP, setatPlusCGEREP, test_gen, queatPlusCGEREP, "%s: (0-2),(0,1)") /* GPRS event reporting */
820 {"+CGMI", AT_CMD_CGMI, atPlusCGMI, test_gen, 0, 0},
821 {"+CGMM", AT_CMD_CGMM, atPlusCGMM, test_gen, 0, 0},
822 {"+CGMR", AT_CMD_CGMR, atPlusCGMR, test_gen, 0, 0},
823 GPRS_CMD("+CGPADDR",AT_CMD_CGPADDR,setatPlusCGPADDR, tesatPlusCGPADDR, 0, 0) /* GPRS: show PDP addresses */
824 GPRS_CMD("+CGQMIN", AT_CMD_CGQMIN, setatPlusCGQMIN, test_gen, queatPlusCGQMIN, "%s: \"IP\",(1-3),(1-4),(1-5),(1-9),(1-18,31)") /* GPRS: context min QOS requirement */
825 GPRS_CMD("+CGQREQ", AT_CMD_CGQREQ, setatPlusCGQREQ, test_gen, queatPlusCGQREQ, "%s: \"IP\",(1-3),(1-4),(1-5),(1-9),(1-18,31)") /* GPRS: context QOS request */
826 GPRS_CMD("+CGREG", AT_CMD_CGREG, setatPlusCGREG, test_gen, queatPlusCGREG, "%s: (0-2)") /* GPRS network registration status */
827 GPRS_CMD("+CGSMS", AT_CMD_CGSMS, setatPlusCGSMS, tesatPlusCGSMS, queatPlusCGSMS, 0) /* GPRS: define MO SMS behaviour */
828 {"+CGSN", AT_CMD_CGSN, atPlusCGSN, test_gen, 0, 0},
829 {"+CHLD", AT_CMD_CHLD, setatPlusCHLD, test_gen, 0/*return cl*/, "%s: (0,1,1x,2,2x,3,4)"},
830 {"+CHUP", AT_CMD_CHUP, setatPlusCHUP, test_gen, 0, 0},
831 {"+CIMI", AT_CMD_CIMI, setatPlusCIMI, test_gen, 0, 0},
832 {"+CLAC", AT_CMD_CLAC, atPlusCLAC, 0, 0, 0},
833 {"+CLAE", AT_CMD_CLAE, setatPlusCLAE, test_gen, queatPlusCLAE, "%s: (0-1)"},
834 {"+CLAN", AT_CMD_CLAN, setatPlusCLAN, tesatPlusCLAN, queatPlusCLAN, 0},
835 {"+CLCC", AT_CMD_CLCC, setatPlusCLCC, test_gen, 0, 0},
836 {"+CLCK", AT_CMD_CLCK, setatPlusCLCK, test_gen, 0, "%s: (\"SC\",\"AO\",\"OI\",\"OX\",\"AI\",\"IR\",\"AB\",\"AG\",\"AC\",\"FD\",\"PS\",\"PN\",\"PU\",\"PP\",\"PC\",\"PF\",\"AL\")"},
837 {"+CLIP", AT_CMD_CLIP, setatPlusCLIP, test_gen, queatPlusCLIP, "%s: (0,1)"},
838 {"+CDIP", AT_CMD_CDIP, setatPlusCDIP, test_gen, queatPlusCDIP, "%s: (0,1)"},
839 {"+CLIR", AT_CMD_CLIR, setatPlusCLIR, test_gen, queatPlusCLIR, "%s: (0,1,2)"},
840 {"+CLVL", AT_CMD_CLVL, setatPlusCLVL, tesatPlusCLVL, queatPlusCLVL, 0},
841 {"+CMEE", AT_CMD_CMEE, setatPlusCMEE, test_gen, queatPlusCMEE, "%s: (0-2)"},
842 {"+CMGC", AT_CMD_CMGC, atPlusCMGC, tesatPlusCMGC, 0, 0},
843 {"+CMGD", AT_CMD_CMGD, setatPlusCMGD, test_gen, 0, "%s: (0-255),(0-4)"},
844 {"+CMGF", AT_CMD_CMGF, atPlusCMGF, test_gen, queatPlusCMGF, CMGF_TEST_OUTPUT},
845 #ifdef SIM_PERS
846 {"%MEPD", AT_CMD_MEPD, setatPercentMEPD, test_gen, 0, "%s: (\"MAX\",\"ALE\",\"RFM\",\"RFA\",\"RSM\",\"RSA\",\"TMF\",\"ETF\",\"AIF\")"},
847 /*For %MEPD -for querying ME Personalisation Data... Added on 11/03/2005*/
848 #endif
849
850 SMBS_CMD("%SMBS", AT_CMD_SMBS, setatPercentSMBS, test_gen, queatPercentSMBS, "%s: (0,1)")
851 {"+CMGL", AT_CMD_CMGL, atPlusCMGL, tesatPlusCMGL, queatPlusCMGL, "%s: \"REC UNREAD\", \"REC READ\", \"STO UNSENT\", \"STO SENT\", \"ALL\""},
852 {"+CMGR", AT_CMD_CMGR, atPlusCMGR, test_gen, test_gen, 0},
853 {"+CMGS", AT_CMD_CMGS, atPlusCMGS, tesatPlusCMGS, queatPlusCMGS, 0},
854 {"+CMGW", AT_CMD_CMGW, atPlusCMGW, tesatPlusCMGW, queatPlusCMGW, 0},
855 {"+CMOD", AT_CMD_CMOD, setatPlusCMOD, test_gen, queatPlusCMOD, "%s: (0-3)"},
856 {"+CMSS", AT_CMD_CMSS, atPlusCMSS, test_gen, 0, 0},
857 {"+CMMS", AT_CMD_CMMS, setatPlusCMMS, test_gen, queatPlusCMMS, "%s: (0-2)"},
858 {"+CMUT", AT_CMD_CMUT, setatPlusCMUT, tesatPlusCMUT, queatPlusCMUT, 0},
859 {"+CMUX", AT_CMD_CMUX, setatPlusCMUX, tesatPlusCMUX, queatPlusCMUX, 0},
860 {"+CNMA", AT_CMD_CNMA, atPlusCNMA, tesatPlusCNMA, queatPlusCNMA, 0},
861 {"+CNMI", AT_CMD_CNMI, atPlusCNMI, tesatPlusCNMI, queatPlusCNMI, 0},
862 {"+CNUM", AT_CMD_CNUM, setatPlusCNUM, test_gen, 0, 0},
863 {"+COLP", AT_CMD_COLP, setatPlusCOLP, test_gen, queatPlusCOLP, "%s: (0,1)"},
864 {"+COPN", AT_CMD_COPN, setatPlusCOPN, test_gen, 0, 0},
865 {"+COPS", AT_CMD_COPS, setatPlusCOPS, tesatPlusCOPS, queatPlusCOPS, 0},
866 {"+CPAS", AT_CMD_CPAS, setatPlusCPAS, test_gen, 0, "%s: (0-5)"},
867 {"+CPBF", AT_CMD_CPBF, setatPlusCPBF, tesatPlusCPBF, 0, 0},
868 {"+CPBR", AT_CMD_CPBR, setatPlusCPBR, tesatPlusCPBR, 0, 0},
869 {"+CPBS", AT_CMD_CPBS, setatPlusCPBS, test_gen, queatPlusCPBS, "%s: (\"EN\",\"BD\",\"FD\",\"DC\",\"LD\",\"RC\",\"LR\",\"MT\",\"AD\",\"SM\",\"SD\",\"MC\",\"LM\",\"AF\",\"ON\",\"UD\")"},
870 {"+CPBW", AT_CMD_CPBW, setatPlusCPBW, tesatPlusCPBW, test_gen, 0},
871 {"+CPIN", AT_CMD_CPIN, setatPlusCPIN, test_gen, queatPlusCPIN, 0},
872 {"+CPMS", AT_CMD_CPMS, atPlusCPMS, test_gen, queatPlusCPMS, "%s: (\"ME\",\"SM\"),(\"ME\",\"SM\"),(\"ME\",\"SM\")"},
873 {"+CPOL", AT_CMD_CPOL, setatPlusCPOL, tesatPlusCPOL, queatPlusCPOL, 0},
874 {"+CPUC", AT_CMD_CPUC, setatPlusCPUC, test_gen, queatPlusCPUC, 0},
875 {"+CPWD", AT_CMD_CPWD, setatPlusCPWD, test_gen, 0, "%s: (\"SC\",8),(\"AO\",4),(\"OI\",4),(\"OX\",4),(\"AI\",4),(\"IR\",4),(\"AB\",4),(\"AG\",4),(\"AC\",4),(\"P2\",8),(\"PS\",16),(\"PF\",16),(\"PN\",16),(\"PU\",16),(\"PP\",16),(\"PC\",16)"},
876 {"+CR", AT_CMD_CR, setatPlusCR, test_gen, queatPlusCR, "%s: (0,1)"},
877 {"+CRC", AT_CMD_CRC, setatPlusCRC, test_gen, queatPlusCRC, "%s: (0,1)"},
878 {"+CREG", AT_CMD_CREG, setatPlusCREG, test_gen, queatPlusCREG, "%s: (0-2)"},
879 {"+CRES", AT_CMD_CRES, atPlusCRES, tesatPlusCRES, 0, 0},
880 FD_CMD("+CRLP", AT_CMD_CRLP, setatPlusCRLP, test_gen, queatPlusCRLP, "%s: (0-61),(0-61),(39-255),(1-255)")
881 {"+CRSL", AT_CMD_CRSL, setatPlusCRSL, tesatPlusCRSL, queatPlusCRSL, 0},
882 {"+CRSM", AT_CMD_CRSM, setatPlusCRSM, test_gen, 0, 0},
883 {"+CSAS", AT_CMD_CSAS, atPlusCSAS, tesatPlusCSAS, 0, 0},
884 {"+CSCA", AT_CMD_CSCA, atPlusCSCA, test_gen, queatPlusCSCA, 0},
885 {"+CSCB", AT_CMD_CSCB, atPlusCSCB, test_gen, queatPlusCSCB, "%s: (0,1)"},
886 {"+CSCS", AT_CMD_CSCS, setatPlusCSCS, test_gen, queatPlusCSCS, "%s: \"GSM\",\"IRA\",\"PCCP437\",\"PCDN\",\"8859-1\",\"HEX\",\"UCS2\""},
887 {"+CSDH", AT_CMD_CSDH, atPlusCSDH, test_gen, queatPlusCSDH, "%s: (0,1)"},
888 {"+CSIM", AT_CMD_CSIM, setatPlusCSIM, test_gen, 0, 0},
889 {"+CSMP", AT_CMD_CSMP, atPlusCSMP, test_gen, queatPlusCSMP, 0},
890 {"+CSMS", AT_CMD_CSMS, atPlusCSMS, test_gen, queatPlusCSMS, "%s: (0,1)"},
891 {"+CSNS", AT_CMD_CSNS, setatPlusCSNS, test_gen, queatPlusCSNS, "%s: (0-7)"},
892 {"+CSQ", AT_CMD_CSQ, setatPlusCSQ, tesatPlusCSQ, 0, 0},
893 {"%CSQ", AT_CMD_P_CSQ,setatPercentCSQ, tesatPercentCSQ,queatPercentCSQ, "%s: (0,1)"},
894 {"+CSSN", AT_CMD_CSSN, setatPlusCSSN, test_gen, queatPlusCSSN, "%s: (0,1),(0,1)"},
895 {"+CSTA", AT_CMD_CSTA, setatPlusCSTA, test_gen, queatPlusCSTA, "%s: (129,145)"},
896 {"+CSVM", AT_CMD_CSVM, setatPlusCSVM, test_gen, queatPlusCSVM, "%s: (0,1),(129,145,161)"},
897 {"+CTFR", AT_CMD_CTFR, setatPlusCTFR, test_gen, 0, 0},
898 {"+CUSD", AT_CMD_CUSD, setatPlusCUSD, test_gen, queatPlusCUSD, "%s: (0,1,2)"},
899 FD_CMD("+DR", AT_CMD_DR, setatPlusDR, test_gen, queatPlusDR, "%s: (0,1)")
900 V42_CMD("+DS", AT_CMD_DS, setatPlusDS, test_gen, queatPlusDS , "%s: (0-3),(0,1),(512-65535),(6-250)")
901
902 #if defined (FF_FAX) AND defined (DTI)
903 FD_CMD("+FAP", AT_CMD_FAP, setatPlusFAP, test_gen, queatPlusFAP, "%s:(0,1),(0,1),(0,1)")
904 FD_CMD("+FBO", AT_CMD_FBO, setatPlusFBO, test_gen, queatPlusFBO, "%s:(0-3)")
905 FD_CMD("+FBS", AT_CMD_FBS, 0, 0, queatPlusFBS, 0)
906 FD_CMD("+FBU", AT_CMD_FBU, setatPlusFBU, test_gen, queatPlusFBU, "%s:(0-1)")
907 FD_CMD("+FCC", AT_CMD_FCC, setatPlusFCC, test_gen, queatPlusFCC, "%s:(0-64),(0-5),(0-2),(0-2),(0),(0),(0),(0-7),(0)")
908 FD_CMD("+FCLASS", AT_CMD_FCLASS,setatPlusFCLASS,test_gen, queatPlusFCLASS, "0,2.0,8")
909 FD_CMD("+FCQ", AT_CMD_FCQ, setatPlusFCQ, test_gen, queatPlusFCQ, "%s:(0-2),(0-2)")
910 FD_CMD("+FCR", AT_CMD_FCR, setatPlusFCR, test_gen, queatPlusFCR, "%s:(0,1)")
911 FD_CMD("+FCS", AT_CMD_FCS, 0, 0, queatPlusFCS, 0)
912 FD_CMD("+FCT", AT_CMD_FCT, setatPlusFCT, test_gen, queatPlusFCT, "%s:(1E)")
913 FD_CMD("+FDR", AT_CMD_FDR, setatPlusFDR, 0, 0, 0)
914 FD_CMD("+FDT", AT_CMD_FDT, setatPlusFDT, 0, 0, 0)
915 FD_CMD("+FEA", AT_CMD_FEA, setatPlusFEA, test_gen, queatPlusFEA, "%s:(0)")
916 FD_CMD("+FFC", AT_CMD_FFC, setatPlusFFC, test_gen, queatPlusFFC, "%s:(0),(0),(0),(0)")
917 FD_CMD("+FHS", AT_CMD_FHS, 0, 0, queatPlusFHS, 0)
918 FD_CMD("+FIE", AT_CMD_FIE, setatPlusFIE, test_gen, queatPlusFIE, "%s:(0,1)")
919 FD_CMD("+FIP", AT_CMD_FIP, setatPlusFIP, 0, 0, 0)
920 FD_CMD("+FIS", AT_CMD_FIS, setatPlusFIS, test_gen, queatPlusFIS, "%s:(0-64),(0-5),(0-4),(0-2),(0),(0),(0),(0-7),(0)")
921 FD_CMD("+FIT", AT_CMD_FIT, setatPlusFIT, test_gen, queatPlusFIT, "%s:(0-255),(0,1)")
922 FD_CMD("+FKS", AT_CMD_FKS, setatPlusFKS, 0, 0, 0)
923 FD_CMD("+FLI", AT_CMD_FLI, setatPlusFLI, test_gen, queatPlusFLI, "%s:\"(20-7E)\"")
924 FD_CMD("+FLO", AT_CMD_FLO, setatPlusFLO, test_gen, queatPlusFLO, "%s: (0-2)")
925 FD_CMD("+FLP", AT_CMD_FLP, setatPlusFLP, test_gen, queatPlusFLP, "%s:(0,1)")
926 FD_CMD("+FMI", AT_CMD_FMI, 0, 0, atPlusFMI, 0)
927 FD_CMD("+FMM", AT_CMD_FMM, 0, 0, atPlusFMM, 0)
928 FD_CMD("+FMR", AT_CMD_FMR, 0, 0, atPlusFMR, 0)
929 FD_CMD("+FMS", AT_CMD_FMS, setatPlusFMS, test_gen, queatPlusFMS, "%s:(0-5)")
930 FD_CMD("+FND", AT_CMD_FND, setatPlusFND, test_gen, queatPlusFND, "%s:(0,1)")
931 FD_CMD("+FNR", AT_CMD_FNR, setatPlusFNR, test_gen, queatPlusFNR, "%s:(0,1),(0,1),(0,1),(0,1)")
932 FD_CMD("+FNS", AT_CMD_FNS, setatPlusFNS, test_gen, queatPlusFNS, "%s:35")
933 FD_CMD("+FPA", AT_CMD_FPA, setatPlusFPA, test_gen, queatPlusFPA, "%s:\"(20-7E)\"")
934 FD_CMD("+FPI", AT_CMD_FPI, setatPlusFPI, test_gen, queatPlusFPI, "%s:\"(20-7E)\"")
935 FD_CMD("+FPS", AT_CMD_FPS, setatPlusFPS, test_gen, queatPlusFPS, "%s:(1-5)")
936 FD_CMD("+FPW", AT_CMD_FPW, setatPlusFPW, test_gen, queatPlusFPW, "%s:\"(20-7E)\"")
937 FD_CMD("+FRQ", AT_CMD_FRQ, setatPlusFRQ, test_gen, queatPlusFRQ, "%s:(0),(0)")
938 FD_CMD("+FSA", AT_CMD_FSA, setatPlusFSA, test_gen, queatPlusFSA, "%s:\"(20-7E)\"")
939 FD_CMD("+FSP", AT_CMD_FSP, setatPlusFSP, test_gen, queatPlusFSP, "%s:(0,1)")
940 #endif /* FF_FAX */
941
942 {"+GCAP", AT_CMD_GCAP, atPlusGCAP, 0, atPlusGCAP, 0},
943 {"+GCI", AT_CMD_GCI, setatPlusGCI, 0, queatPlusGCI, 0},
944 {"+GMI", AT_CMD_GMI, atPlusCGMI, test_gen, 0, 0},
945 {"+GMM", AT_CMD_GMM, atPlusCGMM, test_gen, 0, 0},
946 {"+GMR", AT_CMD_GMR, atPlusCGMR, test_gen, 0, 0},
947 {"+GSN", AT_CMD_GSN, atPlusCGSN, test_gen, 0, 0},
948 {"+ICF", AT_CMD_ICF, setatPlusICF, test_gen, queatPlusICF, "%s: (1-6),(0-3)"},
949 {"+IFC", AT_CMD_IFC, setatPlusIFC, test_gen, queatPlusIFC, "%s: (0-2),(0-2)"},
950 {"+ILRR", AT_CMD_ILRR, setatPlusILRR, test_gen, queatPlusILRR, "%s: (0,1)"},
951 {"+IPR", AT_CMD_IPR, setatPlusIPR, test_gen, queatPlusIPR, "%s: (0,1200,2400,4800,9600,14400,19200,28800,38400,57600,115200),(75,150,300,600,1200,2400,4800,7200,9600,14400,19200,28800,33900,38400,57600,115200)"},
952 {"+VTS", AT_CMD_VST, setatPlusVTS, test_gen, 0, "%s: (0-9,#,*,A-D),(1-255)"},
953 {"+WS46", AT_CMD_WS46, setatPlusWS46, test_gen, queatPlusWS46, "%s: (12)"},
954 {"%ALS", AT_CMD_ALS, setatPercentALS, tesatPercentALS,queatPercentALS, 0},
955 {"%ATR", AT_CMD_ATR, 0, test_gen, queatPercentATR, 0},
956 LOC_CMD("+CLSA", AT_CMD_CLSA, setatPlusCLSA, test_gen, queatPlusCLSA, "%s: (0,1)")
957 LOC_CMD("+CLOM", AT_CMD_CLOM, setatPlusCLOM, test_gen, queatPlusCLOM, "%s: (0,1)")
958 LOC_CMD("+CLPS", AT_CMD_CLPS, setatPlusCLPS, test_gen, queatPlusCLPS, "%s: (0,1),(1-5),(1-120)")
959 LOC_CMD("+CLSR", AT_CMD_CLSR, setatPlusCLSR, test_gen, 0, "%s: (0,1),(0,1),(0,1)")
960 {"%BAND", AT_CMD_BAND, setatPercentBAND, tesatPercentBAND,queatPercentBAND, 0},
961 {"%CACM", AT_CMD_P_CACM,atPercentCACM, test_gen, 0, 0},
962 {"%CAOC", AT_CMD_P_CAOC,atPercentCAOC, test_gen, 0, 0},
963 {"%CCBS", AT_CMD_CCBS, setatPercentCCBS, test_gen, queatPercentCCBS, "%s: (0,1),(0-5)"},
964 {"%STDR", AT_CMD_STDR, setatPercentSTDR, test_gen, 0, 0},
965 GPRS_CMD("%CGAATT", AT_CMD_CGAATT,setatPercentCGAATT,test_gen, queatPercentCGAATT,"%s: (0,1),(0,1)") /* GPRS: GPRS attach/detach mode */
966 GPRS_CMD("%CGMM", AT_CMD_P_CGMM,setatPercentCGMM, test_gen, 0, "%s: (0,1),(0,1)")
967 GPRS_CMD("%CGREG", AT_CMD_P_CGREG,setatPercentCGREG,test_gen, queatPercentCGREG, "%s: (0-3)") /* extended GPRS network registration status */
968 {"%CNAP", AT_CMD_CNAP, setatPercentCNAP, test_gen, queatPercentCNAP, "%s: (0,1)"},
969 {"%CPI", AT_CMD_CPI, setatPercentCPI, test_gen, queatPercentCPI, "%s: (0-4)"},
970 TTY_CMD("%CTTY", AT_CMD_CTTY, setatPercentCTTY, test_gen, queatPercentCTTY, "%s: (0,1),(0-3)")
971 {"%COLR", AT_CMD_COLR, atPercentCOLR, test_gen, 0, 0},
972 {"%CPRIM", AT_CMD_CPRIM,atPercentCPRIM, test_gen, 0, 0},
973 {"%CTV", AT_CMD_CTV, atPercentCTV, test_gen, 0, 0},
974 {"%CUNS", AT_CMD_CUNS, setatPercentCUNS, test_gen, queatPercentCUNS, "%s: (0-2)"},
975 {"%NRG", AT_CMD_NRG, setatPercentNRG, tesatPercentNRG,queatPercentNRG, 0},
976 #if defined(FF_WAP) || defined(FF_TCP_IP) || defined(FF_SAT_E)
977 {"%PPP", AT_CMD_PPP, atPercentPPP, test_gen, queatPercentPPP, "%s: (0-3)"},
978 #endif /* defined(WAP) || defined(FF_TCP_IP) || defned(FF_SAT_E) */
979 SAT_CMD("%SATC", AT_CMD_SATC, setatPercentSATC, tesatPercentSATC,queatPercentSATC, 0)
980 SAT_CMD("%SATE", AT_CMD_SATE, atPercentSATE, test_gen, 0, 0)
981 SAT_CMD("%SATR", AT_CMD_SATR, atPercentSATR, test_gen, 0, 0)
982 SAT_CMD("%SATT", AT_CMD_SATT, atPercentSATT, test_gen, 0, 0)
983 MTST_CMD("%MTST", AT_CMD_MTST, setatPercentMTST, test_gen, 0, "%s: (0,1)")
984 GPRS_CMD("%SNCNT", AT_CMD_SNCNT,setatPercentSNCNT,test_gen, queatPercentSNCNT, "%s: (0)")
985 {"%VER", AT_CMD_VER, atPercentVER, test_gen, 0, 0},
986 GPRS_CMD("%CGCLASS",AT_CMD_P_CGCLASS,setatPercentCGCLASS,test_gen, queatPercentCGCLASS, "%s: (\"B\",\"BG\",\"BC\",\"BX\",\"CG\",\"CC\")")
987 GPRS_CMD("%CGPCO", AT_CMD_CGPCO,setatPercentCGPCO,test_gen, 0, "%s: (0,1),(0,1),(1-2)")
988 GPRS_CMD("%CGPPP", AT_CMD_CGPPP,setatPercentCGPPP,test_gen, queatPercentCGPPP, "%s: (0-3)")
989 EM_CMD ("%EM", AT_CMD_EM, setatPercentEM, test_gen, 0, "%s: (2-3),(1-13)")
990 EM_CMD ("%EMET", AT_CMD_EMET, setatPercentEMET, test_gen, 0, "%s: (1-8)")
991 EM_CMD ("%EMETS", AT_CMD_EMETS,setatPercentEMETS,test_gen, 0, "%s: (1-8),(FFFFFFFF),(FFFFFFFF)")
992 WAP_CMD("%WAP", AT_CMD_WAP, atPercentWAP, test_gen, 0, 0)
993 HZ_CMD ("%CBHZ", AT_CMD_CBHZ, setatPercentCBHZ, tesatPercentCBHZ,queatPercentCBHZ, 0)
994 CPHS_CMD("%CPHS", AT_CMD_CPHS, setatPercentCPHS, test_gen, queatPercentCPHS, "%s: (0-2)")
995 CPHS_CMD("%CPNUMS", AT_CMD_CPNUMS,setatPercentCPNUMS,tesatPercentCPNUMS, 0, 0)
996 CPHS_CMD("%CPALS", AT_CMD_CPALS,setatPercentCPALS,tesatPercentCPALS,queatPercentCPALS, 0)
997 CPHS_CMD("%CPVWI", AT_CMD_CPVWI,setatPercentCPVWI,test_gen, 0, "%s: (0-2),(1,256)")
998 CPHS_CMD("%CPOPN", AT_CMD_CPOPN,0, test_gen, queatPercentCPOPN, 0)
999 CPHS_CMD("%CPCFU", AT_CMD_CPCFU,setatPercentCPCFU,test_gen, 0, "%s: (0-2),(1,256)")
1000 CPHS_CMD("%CPINF", AT_CMD_CPINF,setatPercentCPINF,test_gen, queatPercentCPINF, 0)
1001 CPHS_CMD("%CPMB", AT_CMD_CPMB, setatPercentCPMB, test_gen, queatPercentCPMB, "%s: 4")
1002 {"%CPRI", AT_CMD_CPRI, setatPercentCPRI, test_gen, queatPercentCPRI, "%s: (0,1)"},
1003 #ifdef DTI
1004 {"%DATA", AT_CMD_DATA, setatPercentDATA, test_gen, queatPercentDATA, "%s: (0,1,2)"},
1005 {"%DINF", AT_CMD_DINF, setatPercentDINF, test_gen, 0, "%s: (0,1)"},
1006 #endif
1007 {"%CLCC", AT_CMD_P_CLCC,setatPercentCLCC,test_gen, 0, 0},
1008 {"%DBGINFO", AT_CMD_P_DBGINFO,setatPercentDBGINFO, test_gen, 0, 0},
1009 {"%VTS", AT_CMD_P_VST, setatPercentVTS,test_gen, 0, "%s: (0,1,2,3,4,5,6,7,8,9,A,B,C,D,#,*),(0-2)"},
1010 {"%CHPL", AT_CMD_CHPL, setatPercentCHPL, test_gen, 0, "%s: (0,1,2)"},
1011 {"%CREG", AT_CMD_P_CREG,setatPercentCREG,test_gen, queatPercentCREG, "%s: (0-2)"},
1012 {"+CTZR", AT_CMD_CTZR, setatPlusCTZR, test_gen, queatPlusCTZR, "%s: (0,1)"},
1013 {"+CTZU", AT_CMD_CTZU, setatPlusCTZU, test_gen, queatPlusCTZU, "%s: (0,1)"},
1014 {"%CTZV", AT_CMD_P_CTZV, setatPercentCTZV, test_gen, queatPercentCTZV, "%s: (0,1)"},
1015 {"%CNIV", AT_CMD_P_CNIV, setatPercentCNIV, test_gen, queatPercentCNIV, "%s: (0,1)"},
1016 {"%PVRF", AT_CMD_PVRF, setatPercentPVRF, test_gen, queatPercentPVRF, "%s: (0-2)"},
1017 {"%CWUP", AT_CMD_CWUP, setatPercentCWUP, test_gen, 0, 0},
1018 {"%DAR", AT_CMD_DAR, setatPercentDAR, test_gen, 0, 0},
1019 {"+CIND", AT_CMD_CIND, setatPlusCIND, test_gen, queatPlusCIND, "%s: (\"signal\", (0-5)), (\"smsfull\", (0-1))"},
1020 {"+CMER", AT_CMD_CMER, setatPlusCMER, test_gen, queatPlusCMER, "%s: (0-2), (0), (0), (0-2), (0,1)"},
1021 {"%CSCN", AT_CMD_CSCN, setatPercentCSCN, test_gen, queatPercentCSCN, "%s: (0,1),(0,1,2),(0,1),(0,1,2)"},
1022 MFW_CMD("%MMITEST", AT_CMD_NONE, setatPercentMMITEST, test_gen, 0, 0)
1023 {"%RDL", AT_CMD_RDL, setatPercentRDL, test_gen, queatPercentRDL, "%s: (0,1),(0,1)"},
1024 {"%RDLB", AT_CMD_RDLB, setatPercentRDLB, test_gen, queatPercentRDLB, "%s: (10),(0,1)"},
1025 {"%CSTAT", AT_CMD_CSTAT,setatPercentCSTAT,test_gen, queatPercentCSTAT, "%s: (0,1)"},
1026 {"%CPRSM", AT_CMD_CPRSM,setatPercentCPRSM,test_gen, queatPercentCPRSM, "%s: (0,1)"},
1027 {"%CHLD", AT_CMD_P_CHLD, setatPercentCHLD, test_gen, 0, "%s: (0,1,1x,2,2x,3,4,6,6x,7x,h|H,i|I)"},
1028 {"%SIMIND", AT_CMD_P_SIMIND, setatPercentSIMIND, test_gen, queatPercentSIMIND,"%s: (0,1)"},
1029 {"%SECP", AT_CMD_P_SECP, setatPercentSECP, test_gen, 0, 0},
1030 {"%SECS", AT_CMD_P_SECS, setatPercentSECS, test_gen, quetatPercentSECS, "%s: (0,1)"},
1031 {"%CSSN", AT_CMD_P_CSSN,setatPercentCSSN,test_gen,queatPercentCSSN,"%s: (0,1,2),(0,1)"},
1032 {"+CCLK", AT_CMD_CCLK, setatPlusCCLK, test_gen, queatPlusCCLK, 0},
1033 {"%CSSD", AT_CMD_CSSD, atPercentCSSD, test_gen, 0, 0},
1034 {"%COPS", AT_CMD_P_COPS, setatPercentCOPS, tesatPercentCOPS, queatPercentCOPS, 0},
1035
1036 CPHS_CMD("%CPMBW", AT_CMD_CPMBW, setatPercentCPMBW, tesatPercentCPMBW,0, 0)
1037 {"%CUST", AT_CMD_CUST, setatPercentCUST, test_gen, queatPercentCUST, "%s: (0,1)"},
1038 {"%SATCC", AT_CMD_SATCC,setatPercentSATCC, test_gen, queatPercentSATCC, "%s: (0,1)"},
1039 {"%COPN", AT_CMD_P_COPN, setatPercentCOPN, test_gen, 0, 0},
1040 GPRS_CMD("%CGEREP", AT_CMD_P_CGEREP, setatPercentCGEREP, test_gen, queatPercentCGEREP, "%s: (0,1)") /* GPRS event reporting */
1041 #ifdef FF_DUAL_SIM
1042 {"%SIM", AT_CMD_SIM, setatPercentSIM, test_gen, queatPercentSIM, "%s: (0-2)"},
1043 #endif /*FF_DUAL_SIM*/
1044 #ifdef _SIMULATION_
1045 {"%CUSCFG", AT_CMD_CUSCFG, setatPercentCUSCFG, test_gen, 0, "%s: (\"CCMOSM\", (0-2)),(\"CCMOC\", (0-2)),(\"CCMOSS\",(0-2)), (\"CCMOUSSD\", (0-2)) ,(\"2BDIAL\",(0-2)), (\"EUSSDR\", (0-2))"},
1046 #else
1047 {"%CUSCFG", AT_CMD_CUSCFG, setatPercentCUSCFG, 0, 0, 0},
1048 #endif
1049 {"%CUSDR", AT_CMD_CUSDR, setatPercentCUSDR, test_gen, 0, "%s: (0-2)"},
1050 {"%CPBS", AT_CMD_P_CPBS, 0 ,test_gen, queatPercentCPBS, 0},
1051 {"%PBCF", AT_CMD_P_PBCF, setatPercentPBCF, test_gen, queatPercentPBCF, "%s: (0-1), (0-1), (0-1)"},
1052 SAT_CMD("%SIMEF", AT_CMD_SIMEF, setatPercentSIMEF, test_gen, queatPercentSIMEF, "%s: (0-1)")
1053 SAT_CMD("%EFRSLT", AT_CMD_EFRSLT, setatPercentEFRSLT, test_gen, 0, "%s: (0-1)")
1054 {"%CMGMDU", AT_CMD_P_CMGMDU, setatPercentCMGMDU, 0, 0, 0},
1055 {"%CMGL", AT_CMD_P_CMGL, atPercentCMGL, tesatPercentCMGL, NULL, 0},
1056 {"%CMGR", AT_CMD_P_CMGR, atPercentCMGR, NULL, NULL, 0},
1057 {"@ST", AT_CMD_P_ST, atAtST, test_gen, queatAtST, "%s: (-26,-23,-20,-17,-14,-11,-8,-5,-2,1)"},
1058 {"@AUL", AT_CMD_P_AUL, atAtAUL, test_gen, queatAtAUL, "%s: (0)"},
1059 {"@POFF", AT_CMD_P_POFF, atAtPOFF, 0, 0, 0},
1060 {"@RST", AT_CMD_P_RST, atAtRST, 0, 0, 0},
1061 {"@SC", AT_CMD_P_SC, atAtSC, 0, 0, 0},
1062 {"@BAND", AT_CMD_P_BAND, atAtBAND, 0, 0, 0},
1063 {NULL,0,0,0,0,0}
1064 };
1065
1066 static const char large_output_cmd[5][6] =
1067 {
1068 {"+COPN"},
1069 {"+CPBF"},
1070 {"+CPBR"},
1071 {"%EM"},
1072 {""}
1073 };
1074
1075
1076 /*==== TYPES ======================================================*/
1077 GLOBAL CHAR *cmdErrStr = NULL; /* Error Message */
1078
1079 GLOBAL T_ACI_AT_CMD curAbrtCmd = AT_CMD_NONE;
1080 GLOBAL T_ACI_LIST *ati_src_list = NULL;
1081
1082 /* if a customer runs its own AT cmd by extension mechanism,
1083 * this variable must be reset to 0xFF when completed or aborted */
1084 GLOBAL UBYTE src_id_ext = 0xFF;
1085
1086 /* global buffer for ioSendxxx */
1087 GLOBAL char g_sa[MAX_CMD_LEN];
1088
1089 LOCAL CHAR** atCmdFwrdLst = NULL;/*command list pointer for the old extension mechanism*/
1090 LOCAL CHAR** atCmdFwrdLst_v2 = NULL;/*command list pointer for the new extension mechanism*/
1091 LOCAL BOOL ext_v2_flag = FALSE;/*the flag of which extension mechanism to be used*/
1092 #ifdef SIM_TOOLKIT
1093 EXTERN void aci_sat_cmd_init (void);
1094 #endif
1095 EXTERN void cmd_clearCnmiBuf (void);
1096
1097 #ifdef FF_ATI
1098 /*
1099 +-------------------------------------------------------------------+
1100 | PROJECT : GSM-PS (6147) MODULE : ACI_UTIL |
1101 | STATE : code ROUTINE : trace_run_cmd_line |
1102 +-------------------------------------------------------------------+
1103
1104 PURPOSE : This function trace the command line
1105 */
1106
1107 void trace_run_cmd_line (char *prefix, UBYTE src_id, char *cmd_name, char *cmd_params)
1108 {
1109 char trcBuf[80], nameBuf[40];
1110 int dst_i;
1111
1112 /* Truncate cmd_name to 40 chars to avoid buffer overflow */
1113 strncpy(nameBuf, cmd_name, 39);
1114 nameBuf[39]= '\0';
1115 if (nameBuf[36]) /* and add trail "..." if needed */
1116 {
1117 nameBuf[38] = nameBuf[37] = nameBuf[36] = '.';
1118 }
1119
1120 dst_i = sprintf (trcBuf, "%s(Src %d) cmd:%s param:", (prefix) ? prefix : "", src_id, nameBuf);
1121
1122 if (dst_i < 79)
1123 {
1124 strncpy(&trcBuf[dst_i], (cmd_params) ? cmd_params : "no param!", 79-dst_i);
1125 }
1126 trcBuf[79] = '\0';
1127
1128 if (trcBuf[76])
1129 {
1130 trcBuf[76] = trcBuf[77] = trcBuf[78] = '.'; /* add trailing "..." if string is >=76 */
1131 }
1132
1133 TRACE_EVENT_P1("%s",trcBuf);
1134 }
1135 #endif
1136
1137
1138 /*
1139 +--------------------------------------------------------------------+
1140 | PROJECT : GSM-F&D (8411) MODULE : ATI |
1141 | STATE : code ROUTINE : map_aci_2_ati_rslt |
1142 +--------------------------------------------------------------------+
1143
1144 PURPOSE : map the result of ACI to ATI
1145
1146 */
1147 T_ATI_RSLT map_aci_2_ati_rslt (T_ACI_RETURN rslt)
1148 {
1149 switch (rslt)
1150 {
1151 default:
1152 case AT_FAIL:
1153 {
1154 if (cmdErrStr EQ '\0')
1155 {
1156 cmdCmeError(CME_ERR_Unknown);
1157 }
1158 return (ATI_FAIL);
1159 }
1160 case AT_BUSY:
1161 return ATI_BUSY;
1162 case AT_EXCT:
1163 return (ATI_EXCT);
1164 case AT_CMPL:
1165 return (ATI_CMPL);
1166 }
1167 }
1168
1169
1170 /*
1171 +--------------------------------------------------------------------+
1172 | PROJECT : GSM-F&D (8411) MODULE : ACI_LST |
1173 | STATE : code ROUTINE : cmhUARTtest_srcId |
1174 +--------------------------------------------------------------------+
1175
1176 PURPOSE : search function for source Id in the structure T_ATI_SRC_PARAMS.
1177
1178 */
1179
1180 GLOBAL BOOL search_ati_src_id (UBYTE src_id, void *elem)
1181 {
1182 T_ATI_SRC_PARAMS *compared = (T_ATI_SRC_PARAMS *)elem;
1183
1184 if (compared NEQ NULL)
1185 if (compared->src_id EQ src_id )
1186 return TRUE;
1187 return FALSE;
1188 }
1189
1190 GLOBAL void ati_creg_init( UBYTE srcId, T_ACI_CREG_CMD cmd )
1191 {
1192 T_ATI_REG_MOD_LAC_CID *mod_lac_cid;
1193
1194 /* set +CREG / %CREG / +CGREG / %CGEREG related parameters */
1195
1196 switch( cmd )
1197 {
1198 case(CREG_CMD):
1199 ati_user_output_cfg[srcId].creg.last_presented_state = CREG_STAT_NotPresent;
1200 mod_lac_cid = &ati_user_output_cfg[srcId].creg.mod_lac_cid;
1201 break;
1202
1203 case(PercentCREG_CMD):
1204 ati_user_output_cfg[srcId].percent_creg.last_presented_state = CREG_STAT_NotPresent;
1205 mod_lac_cid = &ati_user_output_cfg[srcId].percent_creg.mod_lac_cid;
1206 break;
1207
1208
1209 #ifdef GPRS
1210 case(PlusCGREG_CMD):
1211 ati_gprs_user_output_cfg[srcId].plus_cgreg.last_presented_state = CGREG_STAT_NOT_PRESENT;
1212 mod_lac_cid = &ati_gprs_user_output_cfg[srcId].plus_cgreg.mod_lac_cid;
1213 break;
1214
1215 case(PercentCGREG_CMD):
1216 ati_gprs_user_output_cfg[srcId].percent_cgreg.last_presented_state = P_CGREG_STAT_NOT_PRESENT;
1217 mod_lac_cid = &ati_gprs_user_output_cfg[srcId].percent_cgreg.mod_lac_cid;
1218 break;
1219 #endif /* GPRS */
1220
1221 default:
1222 TRACE_ERROR ("ati_creg_init() called with invalid cmd!");
1223 return; /* avoid setting uninitialized mod_lac_cid */
1224
1225 }
1226
1227 mod_lac_cid->pres_mode = CREG_MOD_OFF;
1228 mod_lac_cid->last_presented_lac = NOT_PRESENT_16BIT;
1229 mod_lac_cid->last_presented_cid = NOT_PRESENT_16BIT;
1230 }
1231
1232 /*
1233 +--------------------------------------------------------------------------------+
1234 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1235 | STATE : code ROUTINE : ati_cmd_init_each_source |
1236 +--------------------------------------------------------------------------------+
1237
1238 PURPOSE : initialize ATI parameters for 1 source.
1239
1240 */
1241
1242 GLOBAL void ati_cmd_init_each_source( UBYTE srcId )
1243 {
1244 /* Ensure Id set for CME CMS CEER... */
1245 srcId_cb = srcId ;
1246
1247 ati_user_output_cfg[srcId].atE=1; /* Command Echo ON */
1248 ati_user_output_cfg[srcId].atQ=0; /* Result Code Suppression not suppressed */
1249 ati_user_output_cfg[srcId].atX=0; /* Result Code Selection and Call Progress Monitoring Control:
1250 CONNECT result code is given upon entering online data state.
1251 Dial tone and busy detection are disabled.
1252 */
1253
1254 ati_user_output_cfg[srcId].CR_stat = 0;
1255 ati_user_output_cfg[srcId].CRC_stat = 0;
1256 ati_user_output_cfg[srcId].CLIP_stat = 0;
1257 ati_user_output_cfg[srcId].CDIP_stat = 0;
1258 ati_user_output_cfg[srcId].DR_stat = 0;
1259 ati_user_output_cfg[srcId].ILRR_stat = 0;
1260 ati_user_output_cfg[srcId].CSDH_stat = 1;
1261 ati_user_output_cfg[srcId].CSSI_stat = 0;
1262 ati_user_output_cfg[srcId].CSSU_stat = 0;
1263 ati_user_output_cfg[srcId].CUSD_stat = 0;
1264 ati_user_output_cfg[srcId].CPI_stat = 0;
1265 ati_user_output_cfg[srcId].CCWE_stat = 0;
1266 ati_user_output_cfg[srcId].CAOC_stat = 0;
1267 ati_user_output_cfg[srcId].CMEE_stat = CMEE_MOD_Disable;
1268 ati_user_output_cfg[srcId].SIMIND_stat = 0;
1269 ati_user_output_cfg[srcId].cscsChset = CSCS_CHSET_Ira;
1270
1271 ati_user_output_cfg[srcId].CCWV_charging = CCWV_CHRG_Termination;
1272 ati_user_output_cfg[srcId].cnap_mode = CNAP_DISABLED;
1273
1274 ati_user_output_cfg[srcId].CSTAT_stat = 0;
1275
1276 ati_user_output_cfg[srcId].CPRI_stat = 0;
1277
1278 /* init CREG param */
1279 ati_creg_init(srcId, CREG_CMD);
1280 }
1281
1282 /*
1283 +--------------------------------------------------------------------+
1284 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1285 | STATE : code ROUTINE : ati_cmd_init |
1286 +--------------------------------------------------------------------+
1287
1288 PURPOSE : sets S-Registers to default values ( should be called once at program start)
1289
1290 */
1291
1292 GLOBAL void ati_cmd_init(void)
1293 {
1294 UBYTE i;
1295
1296 TRACE_FUNCTION ("ati_cmd_init()");
1297
1298 at.S[0]=0; /* no auto answer when ring*/
1299 at.S[1]=0; /* holds the number of ring counts */
1300 at.S[3]=13;
1301 at.S[4]=10;
1302 at.S[5]=8;
1303 at.S[6]=2;
1304 at.S[7]=60;
1305 at.S[8]=2;
1306 at.S[10]=1;
1307 at.S30=1;
1308 #ifdef GPRS
1309 at.S99=1; /* automatic reject network initiated context prior the n-th ring */
1310 #endif /* GPRS */
1311 at.s1415.atM=0; /* Monitor Speaker Mode OFF */
1312 at.s1415.atL=0; /* Monitor Speaker Loudness LOW */
1313 at.s1415.atV=1; /* DCE Response Format:
1314 DCE transmits full headers and trailers
1315 and verbose response text.
1316 */
1317 SMS_TEXT_MODE = SMS_TEXT_MODE_NONE;
1318
1319 at.flags.COLP_stat = 0;
1320 at.flags.CCWA_stat = 0;
1321 at.flags.CCBS_stat = 0;
1322 at.rngPrms.srcID_S0 = CMD_SRC_NONE;
1323 #ifdef GPRS
1324 at.rngPrms.srcID_CGAUTO = CMD_SRC_NONE;
1325 #endif
1326 at.rngPrms.rngCnt = 1;
1327 at.rngPrms.isRng = FALSE;
1328 at.rngPrms.mode = CRING_MOD_NotPresent;
1329 at.rngPrms.type1 = CRING_TYP_NotPresent;
1330 at.rngPrms.type2 = CRING_TYP_NotPresent;
1331 at.CNMI_mode = CNMI_MOD_Buffer;
1332 at.CNMI_bfr = CNMI_BFR_Flush;
1333
1334 at.clipPrms.stat = CLIP_STAT_NotPresent;
1335 memset( at.clipPrms.number, 0, sizeof(at.clipPrms.number));
1336 memset(&at.clipPrms.type, 0, sizeof(T_ACI_TOA));
1337 at.clipPrms.validity = PRES_NOT_PRES;
1338 memset( at.clipPrms.subaddr, 0, sizeof(at.clipPrms.subaddr));
1339 memset(&at.clipPrms.satype, 0, sizeof(T_ACI_TOS));
1340 #ifdef NO_ASCIIZ
1341 memset(&at.clipPrms.alpha, 0, sizeof(T_ACI_PB_TEXT));
1342 #else
1343 memset(at.clipPrms.alpha, 0, sizeof(at.clipPrms.alpha));
1344 #endif
1345
1346 #ifdef SIM_TOOLKIT
1347 sat_new_source();
1348 aci_sat_cmd_init();
1349 #endif
1350
1351 cmd_clearCnmiBuf ();
1352
1353 /* for ATI parameters that are source dependant */
1354 for(i=0;i<CMD_SRC_MAX;i++)
1355 {
1356 ati_cmd_init_each_source( i );
1357 #ifdef GPRS
1358 gaci_ati_cmd_init_each_source( i );
1359 #endif /* GPRS */
1360 }
1361 }
1362
1363 /*
1364 +--------------------------------------------------------------------+
1365 | PROJECT : GSM-F&D (8411) MODULE : ATI_CMD |
1366 | STATE : code ROUTINE : ati_cmd_reset |
1367 +--------------------------------------------------------------------+
1368
1369 PURPOSE : sets ATI command Parameter to default values
1370
1371 */
1372
1373 GLOBAL void ati_cmd_reset(UBYTE srcId)
1374 {
1375 TRACE_FUNCTION ("ati_cmd_reset()");
1376
1377 at.S[0]=0; /* no auto answer when ring*/
1378 at.S[1]=0; /* holds the number of ring counts */
1379 at.S[3]=13;
1380 at.S[4]=10;
1381 at.S[5]=8;
1382 at.S[6]=2;
1383 at.S[7]=60;
1384 at.S[8]=2;
1385 at.S[10]=1;
1386 at.S30=1;
1387 #ifdef GPRS
1388 at.S99=1; /* automatic reject network initiated context prior the n-th ring */
1389 #endif /* GPRS */
1390 at.s1415.atM=0; /* Monitor Speaker Mode OFF */
1391 at.s1415.atL=0; /* Monitor Speaker Loudness LOW */
1392 at.s1415.atV=1; /* DCE Response Format:
1393 DCE transmits full headers and trailers
1394 and verbose response text.
1395 */
1396 at.flags.COLP_stat = 0;
1397 at.flags.CCWA_stat = 0;
1398 at.flags.CCBS_stat = 0;
1399
1400 ati_cmd_init_each_source(srcId);
1401 #ifdef GPRS
1402 gaci_ati_cmd_init_each_source(srcId);
1403 #endif /* GPRS */
1404 }
1405
1406 /*
1407 +--------------------------------------------------------------------+
1408 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1409 | STATE : code ROUTINE : compact |
1410 +--------------------------------------------------------------------+
1411
1412 PURPOSE : eliminates whitspaces in commandline
1413
1414 */
1415
1416 GLOBAL USHORT compact (char *s, USHORT len)
1417 {
1418 char *pWrite = s;
1419 char *pRead = s;
1420 BOOL isString = FALSE;
1421
1422 while ( pRead - s < len )
1423 {
1424 if (*pRead EQ '"')
1425 isString = !isString;
1426
1427 if (isString OR *pRead > ' ')
1428 *pWrite++ = *pRead;
1429
1430 pRead++;
1431 }
1432
1433 *pWrite = '\0';
1434
1435 return ( pWrite - s );
1436 }
1437
1438
1439 /*
1440 +--------------------------------------------------------------------+
1441 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1442 | STATE : code ROUTINE : rise |
1443 +--------------------------------------------------------------------+
1444
1445 PURPOSE : changes commands only to upper
1446
1447 */
1448 GLOBAL void rise(char *s, USHORT len)
1449 {
1450 char* begin = s;
1451
1452 while (s - begin < len)
1453 {
1454 if (*s EQ '"')
1455 {
1456 do
1457 {
1458 s++;
1459 } while(s - begin < len AND *s !='"');
1460 }
1461 else
1462 *s=toupper(*s);
1463 s++;
1464 }
1465 }
1466
1467 /*
1468 +--------------------------------------------------------------------+
1469 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1470 | STATE : code ROUTINE : check_str |
1471 +--------------------------------------------------------------------+
1472
1473 PURPOSE : checks given string if characters appear that shouldn't be in the string
1474
1475 */
1476
1477 GLOBAL BOOL check_str(char * string,char * sample)
1478 {
1479 for ( ; *string; string++)
1480 {
1481 if (!strchr(sample, *string))
1482 return FALSE;
1483 }
1484 return TRUE;
1485 }
1486
1487
1488 /*
1489 +--------------------------------------------------------------------+
1490 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1491 | STATE : code ROUTINE : toa_demerge |
1492 +--------------------------------------------------------------------+
1493
1494 PURPOSE : splits TOA octet into TOA structure
1495
1496 */
1497
1498 GLOBAL T_ACI_TOA toa_demerge (SHORT type)
1499 {
1500 T_ACI_TOA toa;
1501
1502 toa.ton = (type & 0x70)>>4;
1503 switch (toa.ton) /*valid values 0-4*/
1504 {
1505 // case TON_NotPresent : // =-1,
1506 case TON_Unknown : // = 0,
1507 case TON_International:
1508 case TON_National :
1509 case TON_NetSpecific :
1510 case TON_DedAccess :
1511 // case TON_Alphanumeric :
1512 // case TON_Abbreviated :
1513 // case TON_Extended : // ffs */
1514 break;
1515
1516 default:
1517 toa.ton = TON_NotPresent;
1518 break;
1519 }
1520
1521 toa.npi = type & 0xF;
1522 switch (toa.npi) /*valid values 0,1,3,4,8,9*/
1523 {
1524 // case NPI_NotPresent : // =-1,
1525 case NPI_Unknown : // = 0,
1526 case NPI_IsdnTelephony: // = 1,
1527 case NPI_Data : // = 3,
1528 case NPI_Telex : // = 4,
1529 case NPI_National : // = 8,
1530 case NPI_Private : // = 9,
1531 // case NPI_ERMES : // = 10, // ffs
1532 // case NPI_CTS : // = 11 // ffs
1533 break;
1534
1535 default:
1536 toa.npi = NPI_NotPresent;
1537 break;
1538 }
1539
1540 return toa;
1541 }
1542
1543 /*
1544 +--------------------------------------------------------------------+
1545 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1546 | STATE : code ROUTINE : tos_merge |
1547 +--------------------------------------------------------------------+
1548
1549 PURPOSE : builds type of sub-address octet from TOS structure
1550
1551 */
1552 GLOBAL SHORT tos_merge (T_ACI_TOS satype)
1553 {
1554 return ((satype.tos << 4) & 0x70)
1555 | ((satype.oe << 3) & 0x08)
1556 | 0x80;
1557 }
1558
1559 /*
1560 +--------------------------------------------------------------------+
1561 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1562 | STATE : code ROUTINE : tos_demerge |
1563 +--------------------------------------------------------------------+
1564
1565 PURPOSE : splits TOS structure into TOS structure
1566
1567 */
1568 GLOBAL T_ACI_TOS tos_demerge (SHORT tsatype)
1569 {
1570 T_ACI_TOS satype;
1571
1572 satype.tos = (tsatype & 0x70) >> 4;
1573 switch(satype.tos) /*valid values 0,2*/
1574 {
1575 // case TOS_NotPresent:// =-1,
1576 case TOS_Nsap :// = 0,
1577 case TOS_User :// = 2
1578 break;
1579
1580 default:
1581 satype.tos = TOS_NotPresent;
1582 break;
1583 }
1584
1585 satype.oe = (tsatype & 0x08) >> 3;
1586 switch(satype.oe) /*valid Values 0,1*/
1587 {
1588 // case OE_NotPresent:// =-1,
1589 case OE_Even :// = 0,
1590 case OE_Odd :// = 1
1591 break;
1592
1593 default:
1594 satype.oe = OE_NotPresent;
1595 break;
1596 }
1597
1598 return satype;
1599 }
1600
1601 /*
1602 +--------------------------------------------------------------------+
1603 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1604 | STATE : code ROUTINE : ci_remTrailCom |
1605 +--------------------------------------------------------------------+
1606
1607 PURPOSE : remove the trailing commas of an output line.
1608
1609 */
1610 GLOBAL void ci_remTrailCom (CHAR* outLine, USHORT len)
1611 {
1612 while (len)
1613 {
1614 if (outLine[--len] EQ ',')
1615 outLine[len] = '\0';
1616 else
1617 break;
1618 }
1619 }
1620
1621
1622 LOCAL void send_output_type_signal (T_ATI_SRC_PARAMS *src_params,
1623 UBYTE output_type)
1624 {
1625 if (src_params->line_state_cb NEQ NULL)
1626 {
1627 src_params->line_state_cb (src_params->src_id,
1628 ATI_LINE_STATE_OUTPUT_TYPE,
1629 (ULONG)output_type);
1630 }
1631 else
1632 {
1633 TRACE_EVENT_P1 ("[WRN] send_output_type_signal: no callback for srcId=%d",
1634 src_params->src_id);
1635 }
1636 }
1637
1638
1639 LOCAL void check_and_send_output_type_signal (T_ATI_SRC_PARAMS *src_params, CHAR *cmd)
1640 {
1641 int i = 0;
1642
1643 while (*large_output_cmd[i] NEQ '\0')
1644 {
1645 if (strcmp (large_output_cmd[i], cmd) EQ 0)
1646 {
1647 TRACE_EVENT("Command necessiting large output detected");
1648
1649 send_output_type_signal (src_params, ATI_OUTPUT_TYPE_LARGE);
1650 return;
1651 }
1652
1653 i++;
1654 }
1655
1656 send_output_type_signal (src_params, ATI_OUTPUT_TYPE_NORMAL);
1657 }
1658
1659
1660
1661 /*
1662 +--------------------------------------------------------------------+
1663 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1664 | STATE : code ROUTINE : aciAbort |
1665 +--------------------------------------------------------------------+
1666
1667 PURPOSE : abort currently executing command
1668
1669 */
1670
1671 GLOBAL void aciAbort (UBYTE srcId)
1672 {
1673 T_ACI_RETURN rslt;
1674 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1675
1676 TRACE_FUNCTION ("aciAbort()");
1677
1678 if ( src_params->curAtCmd EQ AT_CMD_NONE OR
1679 src_params->curAtCmd EQ AT_CMD_ABRT )
1680 {
1681 return;
1682 }
1683
1684 if ( src_params->curAtCmd EQ AT_CMD_EXT )
1685 {
1686 g_sa[0] = ( CHAR ) ACI_EXT_STRG_END;
1687 if (ext_v2_flag EQ TRUE)
1688 {
1689 rslt = rEXT_Abort(srcId);
1690 }
1691 else
1692 {
1693 rslt = rAT_ACP ( g_sa, MAX_CMD_LEN - 1 );
1694 aci_sendPString ( srcId, g_sa );
1695 }
1696 switch ( rslt )
1697 {
1698 case ( AT_EXCT ):
1699 curAbrtCmd = AT_CMD_ABRT;
1700 break;
1701
1702 case ( AT_CMPL ):
1703 src_params->curAtCmd = AT_CMD_NONE;
1704 ledit_ctrl (srcId, LEDIT_CTRL_CMPL, NULL);
1705 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
1706 break;
1707
1708 default:
1709 {
1710 io_sendMessage ( srcId, cmdCmeError ( CME_ERR_FailedToAbort ),
1711 ATI_NORMAL_OUTPUT | ATI_RESULT_CODE_OUTPUT);
1712 }
1713 break;
1714 }
1715 }
1716 else
1717 {
1718 switch ( sAT_Abort (srcId, src_params->curAtCmd) )
1719 {
1720 case ( AT_EXCT ):
1721 curAbrtCmd = AT_CMD_ABRT;
1722 break;
1723
1724 case ( AT_CMPL ):
1725 src_params->curAtCmd = AT_CMD_NONE;
1726 ledit_ctrl (srcId, LEDIT_CTRL_CMPL, NULL);
1727 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
1728 cmdErrStr = NULL;
1729 break;
1730
1731 default:
1732 switch ( src_params->curAtCmd )
1733 {
1734 case ( AT_CMD_CMGC ):
1735 case ( AT_CMD_CNMI ):
1736 case ( AT_CMD_CSMS ):
1737 case ( AT_CMD_CMGD ):
1738 case ( AT_CMD_CMGR ):
1739 case ( AT_CMD_CMGW ):
1740 case ( AT_CMD_CMGS ):
1741 case ( AT_CMD_CMSS ):
1742 case ( AT_CMD_CPMS ):
1743 case ( AT_CMD_CSMP ):
1744 case ( AT_CMD_CSCA ):
1745 case ( AT_CMD_CRES ):
1746 case ( AT_CMD_CSAS ):
1747 case ( AT_CMD_CMGL ):
1748 io_sendMessage ( srcId, cmdCmsError ( CMS_ERR_FailedToAbort ),
1749 ATI_NORMAL_OUTPUT | ATI_RESULT_CODE_OUTPUT);
1750 break;
1751
1752 default:
1753 io_sendMessage ( srcId, cmdCmeError ( CME_ERR_FailedToAbort ),
1754 ATI_NORMAL_OUTPUT | ATI_RESULT_CODE_OUTPUT);
1755 }
1756 break;
1757 }
1758 }
1759 cmdErrStr = NULL;
1760 }
1761
1762 /*
1763 +--------------------------------------------------------------------+
1764 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1765 | STATE : code ROUTINE :ati_execute_sat_cmd |
1766 +--------------------------------------------------------------------+
1767
1768 PURPOSE :
1769
1770 */
1771 #ifdef SIM_TOOLKIT
1772 GLOBAL BOOL ati_execute_sat_cmd (T_ATI_SRC_PARAMS *src_params,
1773 UBYTE *chars, USHORT len)
1774 {
1775 BOOL end_cmd_found = FALSE;
1776 UBYTE i;
1777 T_ACI_SAT_TERM_RESP resp_data;
1778
1779 psaSAT_InitTrmResp( &resp_data );
1780
1781 TRACE_FUNCTION ("ati_execute_sat_cmd ()");
1782
1783 for (i=0; i < len; i++)
1784 {
1785 if( chars[i] EQ '\r' ) /* for SAT hard coded S3=CR */
1786 {
1787 end_cmd_found = TRUE;
1788 break;
1789 }
1790 }
1791
1792 if( !end_cmd_found )
1793 {
1794 TRACE_EVENT("ERROR: run at command not terminated by at.S[3]");
1795 psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
1796 return(FALSE);
1797 }
1798
1799 ati_execute (src_params->src_id, chars, len);
1800 return(TRUE);
1801 }
1802 #endif /* SIM_TOOLKIT */
1803
1804
1805 /*
1806 +-------------------------------------------------------------------+
1807 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
1808 | ROUTINE : ati_execute_config_cmd |
1809 +-------------------------------------------------------------------+
1810
1811 PURPOSE :
1812 */
1813 GLOBAL BOOL ati_execute_config_cmd (UBYTE *chars, USHORT len)
1814 {
1815 BOOL S3_CR_found = FALSE;
1816 UBYTE i;
1817 T_ATI_SRC_PARAMS *src_params = NULL;
1818 static UBYTE cnf_src_id = 0;
1819 T_LEDIT_ATCMD *cmd = NULL;
1820
1821 TRACE_FUNCTION ("ati_execute_config_cmd()");
1822
1823 if (!cnf_src_id)
1824 {
1825 cnf_src_id = ati_init (ATI_SRC_TYPE_TST, NULL, NULL);
1826 if (!cnf_src_id)
1827 {
1828 TRACE_EVENT ("[ERR] ati_execute_config_cmd: cannot create source");
1829 return (FALSE);
1830 }
1831 TRACE_EVENT_P1 ("ati_execute_config_cmd: srcId=%d", cnf_src_id);
1832 }
1833 src_params = find_element (ati_src_list, cnf_src_id, search_ati_src_id);
1834
1835 if (src_params EQ NULL)
1836 {
1837 TRACE_EVENT_P1 ("[ERR] ati_execute_config_cmd: source ID=%d not found",
1838 cnf_src_id);
1839 return (FALSE);
1840 }
1841 if (src_params->cmd_state EQ CMD_RUNNING)
1842 {
1843 if ((ledit_get_current (src_params->src_id, &cmd) EQ LEDIT_CMPL) AND cmd)
1844 {
1845 TRACE_EVENT_P1 ("[WRN] ati_execute_config_cmd: command=%s is running", cmd->name);
1846 }
1847 else
1848 {
1849 TRACE_EVENT ("[ERR] ati_execute_config_cmd: command not available !"); /* then we have a real problem */
1850 }
1851 return (FALSE);
1852 }
1853
1854 for (i=0; i < len; i++)
1855 {
1856 if( chars[i] EQ '\r' ) /* */
1857 {
1858 S3_CR_found = TRUE;
1859 break;
1860 }
1861 }
1862
1863 if (S3_CR_found EQ FALSE)
1864 {
1865 /*
1866 * tell line edit that the line termination is not default '\r'
1867 */
1868 T_LEDIT line;
1869 line.S3 = 0x00; /* <== NULL terminated cmd line */
1870 line.S4 = at.S[4];
1871 line.S5 = at.S[5];
1872 line.smsEnd = 0x1a;
1873 line.atE = ati_user_output_cfg[src_params->src_id].atE;
1874 ledit_set_config (src_params->src_id, line);
1875 len = len+1;
1876 }
1877
1878 ati_execute (src_params->src_id, chars, len);
1879
1880 /* wait for command to be processed before allowing new command */
1881 return (FALSE);
1882 }
1883
1884 /*
1885 +-------------------------------------------------------------------+
1886 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
1887 | ROUTINE : ati_abort |
1888 +-------------------------------------------------------------------+
1889
1890 PURPOSE :
1891 */
1892 GLOBAL BOOL ati_abort (UBYTE src_id)
1893 {
1894 aciAbort (src_id);
1895
1896 return (TRUE);
1897 }
1898
1899 /*
1900 +-------------------------------------------------------------------+
1901 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
1902 | ROUTINE : ati_run_cmd_failed |
1903 +-------------------------------------------------------------------+
1904
1905 PURPOSE :
1906 */
1907 /*
1908 static void ati_run_cmd_failed (UBYTE src_id)
1909 {
1910 T_LEDIT_ERR *err = NULL;
1911 *
1912 * get the error reason
1913 *
1914 ledit_ctrl (src_id,LEDIT_CTRL_ERROR, &err);
1915 if (err AND err->msg)
1916 {
1917 io_sendMessageEx (src_id, err->msg, ATI_CONFIRM_OUTPUT);
1918 }
1919 else
1920 {
1921 io_sendMessageEx (src_id, "PANIC: NULL pointer !", ATI_CONFIRM_OUTPUT);
1922 }
1923 }
1924 */
1925
1926 /*
1927 +-------------------------------------------------------------------+
1928 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
1929 | ROUTINE : ati_run_ext_cmd |
1930 +-------------------------------------------------------------------+
1931
1932 PURPOSE : run a single extended AT command got from line edit
1933 */
1934 static T_ATI_RSLT ati_run_ext_cmd (T_ATI_SRC_PARAMS *src_params, T_LEDIT_ATCMD *cmd)
1935 {
1936 USHORT idx_fun = 0;
1937 TRACE_FUNCTION("ati_run_ext_cmd()");
1938 /*
1939 * doe we have it in cmds[] table ?
1940 */
1941 if ((idx_fun = find_index(cmd->name)) EQ 0)
1942 {
1943 if (ext_v2_flag EQ TRUE)
1944 {
1945 /*
1946 * AT cmd not listed in cmds[], return error
1947 */
1948 cmdCmeError(CME_ERR_OpNotAllow);
1949 return (ATI_FAIL);
1950 }
1951 else
1952 {
1953 /*
1954 * AT cmd not listed in cmds[], so try it with extension mechanism
1955 */
1956 return (aci_FwrdToEXT (src_params, cmd));
1957 }
1958 }
1959
1960 /*
1961 * remember the binary representation of the cmd
1962 */
1963 src_params->curAtCmd = cmds[idx_fun].binKey;
1964
1965 switch (cmd->type.sType)
1966 {
1967 case LEDIT_ATCMD_QUERY:
1968 {
1969 if (cmds[idx_fun].qfnc)
1970 {
1971 return (cmds[idx_fun].qfnc(cmd->params, src_params->src_id));
1972 }
1973 else
1974 {
1975 cmdCmeError(CME_ERR_OpNotAllow);
1976 return (ATI_FAIL); /* no function to query this cmd */
1977 }
1978 }
1979 case LEDIT_ATCMD_SET:
1980 {
1981 if (cmds[idx_fun].sfnc)
1982 {
1983 return (cmds[idx_fun].sfnc(cmd->params, src_params->src_id));
1984 }
1985 else
1986 {
1987 cmdCmeError(CME_ERR_OpNotAllow);
1988 return (ATI_FAIL); /* no function to set this cmd */
1989 }
1990 }
1991 case LEDIT_ATCMD_TEST:
1992 {
1993 if (cmds[idx_fun].tfnc)
1994 {
1995 return (cmds[idx_fun].tfnc(cmd->params, src_params->src_id));
1996 }
1997 else
1998 {
1999 cmdCmeError(CME_ERR_OpNotAllow);
2000 return (ATI_FAIL); /* no function to test this cmd */
2001 }
2002 }
2003 default:
2004 {
2005 cmdCmeError(CME_ERR_Unknown);
2006 return (ATI_FAIL);
2007 }
2008 }
2009 }
2010
2011 /*
2012 +-------------------------------------------------------------------+
2013 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2014 | ROUTINE : ati_run_cmd |
2015 +-------------------------------------------------------------------+
2016
2017 PURPOSE : run a single AT command got from line edit
2018 */
2019 static T_ATI_RSLT ati_run_cmd (T_ATI_SRC_PARAMS *src_params, T_LEDIT_ATCMD *cmd)
2020 {
2021 U16 idx_fun = 0;
2022
2023 cmdErrStr = NULL; /* reset error context */
2024
2025 trace_run_cmd_line ("ati_run_cmd", src_params->src_id, cmd->name, cmd->params);
2026
2027 check_and_send_output_type_signal (src_params, cmd->name);
2028
2029 if ((ext_v2_flag EQ TRUE) AND aci_SrchFwrdLst (src_params->src_id, cmd->name))
2030 {
2031 return (aci_FwrdToEXT (src_params, cmd));
2032 }
2033
2034 switch (cmd->type.mType)
2035 {
2036 /*********************/
2037 case LEDIT_ATCMD_DIAL:
2038 {
2039 return (atD (cmd->params, src_params->src_id));
2040 }
2041 /*********************/
2042 case LEDIT_ATCMD_AND:
2043 {
2044 if (cmds_bas[*(cmd->name) - 'A'].and_fnc NEQ NULL)
2045 {
2046 idx_fun = *(cmd->name) - 'A';
2047 return (cmds_bas[idx_fun].and_fnc(cmd->params, src_params->src_id));
2048 }
2049 else if (ext_v2_flag EQ FALSE)
2050 {
2051 /*
2052 * basic AT& cmd not listed in cmds_bas[], so try it with extension mechanism
2053 */
2054 return (aci_FwrdToEXT (src_params, cmd));
2055 }
2056 return AT_FAIL;
2057 }
2058 /*********************/
2059 case LEDIT_ATCMD_BASIC:
2060 {
2061 if (cmds_bas[*(cmd->name) - 'A'].fnc NEQ NULL)
2062 {
2063 /*
2064 * this is fix for atEFLMQVX, because there is a track backing to the cmd letter
2065 * e.g.: ATE0 -> we put E0 in tmp_buf, but pass &tmp_buf[1] !
2066 */
2067 CHAR tmp_buf[8];
2068 tmp_buf[0] = *(cmd->name);
2069 strcpy(&tmp_buf[1], cmd->params);
2070 idx_fun = *(cmd->name) - 'A';
2071 return (cmds_bas[idx_fun].fnc(&tmp_buf[1], src_params->src_id));
2072 }
2073 else if (ext_v2_flag EQ FALSE)
2074 {
2075 /*
2076 * basic AT cmd not listed in cmds_bas[], so try it with extension mechanism
2077 */
2078 return (aci_FwrdToEXT (src_params, cmd));
2079 }
2080 return AT_FAIL;
2081 }
2082 /*********************/
2083 case LEDIT_ATCMD_S:
2084 {
2085 /*
2086 * unfortunately we have to put the reg number, the cmd type and the params together in one buffer
2087 * else the ATCommand_bas cmds_bas[] does not work
2088 * e.g.: tmpBuf: 3=127 --> came from ATS3=127 --> user want to change termination character to 127
2089 */
2090 char tmpBuf[20];
2091 switch (cmd->type.sType)
2092 {
2093 case LEDIT_ATCMD_QUERY:
2094 {
2095 sprintf(tmpBuf,"%s?", cmd->name+1);
2096 return (atS (tmpBuf, src_params->src_id));
2097 }
2098 case LEDIT_ATCMD_TEST:
2099 {
2100 sprintf(tmpBuf,"%s=?", cmd->name+1);
2101 return (atS (tmpBuf, src_params->src_id));
2102 }
2103 case LEDIT_ATCMD_SET:
2104 {
2105 sprintf(tmpBuf,"%s=%s", cmd->name+1, cmd->params);
2106 return (atS (tmpBuf, src_params->src_id));
2107 }
2108 }
2109 break;
2110 }
2111 /*********************/
2112 case LEDIT_ATCMD_EXTENDED:
2113 {
2114 /*
2115 * do we have to push to extension mechanism ?
2116 */
2117 if (!aci_cmhActive (src_params->src_id) AND aci_SrchFwrdLst (src_params->src_id, cmd->name))
2118 {
2119 if (src_params EQ NULL)
2120 {
2121 TRACE_EVENT ("[ERR] ati_execute: source ID not found");
2122 return (ATI_FAIL);
2123 }
2124 return (aci_FwrdToEXT (src_params, cmd));
2125 }
2126 return (ati_run_ext_cmd (src_params, cmd));
2127 }
2128 } /* end of switch (cmd->type.mType) */
2129
2130 /* default: */
2131 {
2132 cmdCmeError(CME_ERR_OpNotAllow);
2133 return (ATI_FAIL);
2134 }
2135 }
2136
2137 /*
2138 +-------------------------------------------------------------------+
2139 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2140 | ROUTINE : ati_run_cmd_line_next |
2141 +-------------------------------------------------------------------+
2142
2143 PURPOSE : - after line edit processed a raw AT command line to
2144 canonical form, call here the appropriate functions
2145 for each single AT command
2146 */
2147 LOCAL T_ATI_RSLT ati_run_cmd_line_next (T_ATI_SRC_PARAMS *src_params)
2148 {
2149 T_ATI_RSLT rv_ati = ATI_FAIL;
2150 T_LEDIT_ATCMD *cmd = NULL;
2151
2152 if (src_params->text_mode EQ TXT_MODE)
2153 {
2154 /*
2155 * here we are when changed from cmd to text mode
2156 *
2157 * we use the current cmd (e.g.: +CMGS) where the parameter was the destination adress
2158 * but now we put the text as parameter
2159 * example: AT+CMGS="1234567890";+CPBR=1,100
2160 * |__change to text mode (user interactively edit the text)
2161 * "Hello this is SMS text<Ctrl-Z>"
2162 * +CMGS="Hello this is SMS text<Ctrl-Z>" <-- call now CMGS a second time, but with text
2163 */
2164 if ((ledit_get_current (src_params->src_id, &cmd) EQ LEDIT_CMPL) AND cmd)
2165 {
2166 if (ledit_get_text (src_params->src_id, &cmd->params) EQ LEDIT_FAIL)
2167 {
2168 cmdCmeError(CME_ERR_Unknown); /* hmm, internal failure */
2169 }
2170
2171 return (ati_run_cmd (src_params, cmd)); /* process the text */
2172 }
2173 else
2174 {
2175 cmdCmeError(CME_ERR_Unknown); /* hmm, internal failure */
2176 return (ATI_FAIL);
2177 }
2178 }
2179 else /* CMD_MODE */
2180 {
2181 cmd = NULL;
2182 rv_ati = ATI_CMPL; /* when there is no further cmd */
2183 /*
2184 * and possibly next commands follows
2185 * (when the last cmd sent a primitive to another entity,
2186 * then ati_run_cmd_line was called by rCI_OK (asynchroniously),
2187 * instead of ati_execute (the synchronized case))
2188 */
2189
2190 while (ledit_ctrl(src_params->src_id,LEDIT_CTRL_MORE_CMDS, NULL) EQ LEDIT_CMPL)
2191 {
2192 if (ledit_get_next (src_params->src_id, &cmd) EQ LEDIT_FAIL)
2193 return ATI_FAIL;
2194 if (cmd EQ NULL)
2195 return ATI_FAIL;
2196 if ((rv_ati = ati_run_cmd (src_params, cmd)) NEQ ATI_CMPL)
2197 {
2198 break;
2199 }
2200 cmd = NULL;
2201 }
2202 return rv_ati;
2203 }
2204 }
2205
2206 /*
2207 +-------------------------------------------------------------------+
2208 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2209 | ROUTINE : ati_run_cmd_line |
2210 +-------------------------------------------------------------------+
2211
2212 PURPOSE : - after line edit processed a raw AT command line to
2213 canonical form, call here the appropriate functions
2214 for each single AT command
2215 */
2216 LOCAL T_ATI_RSLT ati_run_cmd_line (T_ATI_SRC_PARAMS *src_params)
2217 {
2218 T_ATI_RSLT rv_ati = ATI_FAIL;
2219
2220 T_LEDIT_ATCMD *cmd = NULL;
2221 TRACE_FUNCTION("ati_run_cmd_line()");
2222
2223 if (src_params->cmd_state EQ CMD_TYPING) /* a new command line */
2224 {
2225 trace_cmd_state(src_params->src_id, src_params->cmd_state, CMD_RUNNING);
2226 src_params->cmd_state = CMD_RUNNING;
2227 /*
2228 * start with the first command
2229 */
2230 if ((ledit_get_first (src_params->src_id, &cmd) EQ LEDIT_CMPL) AND cmd)
2231 {
2232 rv_ati = ati_run_cmd (src_params, cmd);
2233 }
2234 else
2235 {
2236 TRACE_EVENT("failed to run first AT command !");
2237 cmdCmeError(CME_ERR_Unknown); /* hmm, internal failure */
2238 }
2239 if (rv_ati EQ ATI_CMPL)
2240 {
2241 rv_ati = ati_run_cmd_line_next (src_params); /* for possible next synchronious cmds */
2242 }
2243 }
2244 else
2245 {
2246 rv_ati = ati_run_cmd_line_next (src_params); /* for asynchronious cmds */
2247 }
2248 /*
2249 * evaluate the return value of the AT cmd
2250 */
2251 if (rv_ati NEQ ATI_EXCT)
2252 {
2253 /*
2254 * tell line edit that the cmd line is finished
2255 * and to be able to receive a new one
2256 */
2257 ledit_ctrl (src_params->src_id,LEDIT_CTRL_CMPL, NULL);
2258
2259 trace_cmd_state(src_params->src_id, src_params->cmd_state, CMD_IDLE);
2260 src_params->cmd_state = CMD_IDLE;
2261 src_params->text_mode = CMD_MODE;
2262 }
2263
2264 switch (rv_ati)
2265 {
2266 case (ATI_CMPL_NO_OUTPUT):
2267 TRACE_EVENT("AT command line processed, but look for rCI_OK for success") ;
2268 break;
2269
2270 case (ATI_CMPL):
2271 /*
2272 * if extension command reset the global src_id_ext
2273 */
2274 if (src_id_ext EQ src_params->src_id)
2275 {
2276 src_id_ext = 0xFF;
2277 }
2278
2279 TRACE_EVENT("AT command line successfully processed") ;
2280 io_sendConfirm (src_params->src_id, cmdAtError(atOk), ATI_NORMAL_OUTPUT);
2281 break;
2282
2283 case (ATI_FAIL):
2284 /*
2285 * if extension command reset the global src_id_ext
2286 */
2287 if (src_id_ext EQ src_params->src_id)
2288 {
2289 src_id_ext = 0xFF;
2290 }
2291
2292 if (cmdErrStr EQ NULL)
2293 {
2294 /* set cmdErrStr to default error */
2295 cmdAtError(atError);
2296 }
2297
2298 io_sendConfirm (src_params->src_id, cmdErrStr, ATI_ERROR_OUTPUT);
2299 cmdErrStr = NULL;
2300 break;
2301
2302 case (ATI_FAIL_NO_OUTPUT):
2303 break;
2304
2305 case (ATI_BUSY):
2306 TRACE_EVENT("BUSY !") ;
2307 cmdCmeError(CME_ERR_Unknown);
2308 io_sendConfirm (src_params->src_id, cmdErrStr, ATI_ERROR_OUTPUT);
2309 cmdErrStr = NULL;
2310 break;
2311
2312 case (ATI_EXCT):
2313 break;
2314
2315 } /* end of switch (rv_ati) */
2316
2317 return (rv_ati);
2318 }
2319
2320
2321 /*
2322 +-------------------------------------------------------------------+
2323 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2324 | ROUTINE : ati_execute_cmd_line |
2325 +-------------------------------------------------------------------+
2326
2327 PURPOSE : called by ati_execute_eval_rslt when LEDIT_CMPL
2328 or LEDIT_ESC (but after <ESC> a SMS there are further cmds).
2329 rCI_OK calls asynchroniously this function, as well
2330 */
2331 /*
2332 * first_prompt is used by ati_execute_cmd_line() and ati_execute_eval_rslt() only
2333 */
2334 static BOOL first_prompt = FALSE;
2335
2336 GLOBAL T_ATI_RSLT ati_execute_cmd_line (T_ATI_SRC_PARAMS *src_params)
2337 {
2338 /*
2339 * process the command line
2340 */
2341 T_ATI_RSLT rv_ati = ati_run_cmd_line (src_params);
2342
2343 if ((rv_ati EQ ATI_EXCT) AND (src_params->text_mode EQ TXT_MODE))
2344 {
2345 if(first_prompt EQ FALSE)
2346 {
2347 /*
2348 * emit the very first prompt "> " when switched from cmd to text mode
2349 */
2350 ledit_ctrl (src_params->src_id,LEDIT_CTRL_PROMPT, NULL);
2351 io_sendMessageEx (src_params->src_id, g_ledit_echoBuf, ATI_CONFIRM_OUTPUT);
2352 first_prompt = TRUE;
2353 }
2354 }
2355 else
2356 {
2357 first_prompt = FALSE; /* reset in CMD_MODE */
2358 }
2359 return (rv_ati);
2360 }
2361
2362 /*
2363 +-------------------------------------------------------------------+
2364 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2365 | ROUTINE : ati_execute_eval_rslt |
2366 +-------------------------------------------------------------------+
2367
2368 PURPOSE : evaluate the result value of line edit and execute the AT cmd line
2369 */
2370 LOCAL T_ATI_RSLT ati_execute_eval_rslt (UBYTE src_id, T_ATI_SRC_PARAMS *src_params, T_LEDIT_RSLT rv_ledit)
2371 {
2372 TRACE_FUNCTION ("ati_execute_eval_rslt()");
2373
2374 if ((rv_ledit EQ LEDIT_FAIL)
2375 OR (rv_ledit EQ LEDIT_OK)) /* for <CR> and [aAtT]<CR> they want to see an OK */
2376 {
2377 ledit_ctrl (src_id,LEDIT_CTRL_CMPL, NULL);
2378 trace_cmd_state(src_params->src_id, src_params->cmd_state, CMD_IDLE);
2379 src_params->cmd_state = CMD_IDLE;
2380 src_params->text_mode = CMD_MODE;
2381 }
2382
2383 switch (rv_ledit)
2384 {
2385 case (LEDIT_CMPL): /* line edit has a valid AT command line or text line */
2386 {
2387 char trcBuf[80];
2388 TRACE_EVENT ("ati_execute_eval_rslt(): rv_ledit = LEDIT_CMPL");
2389 /*
2390 * emit a trace of the entire cmd line
2391 * we have to put the prefix AT here, because ledit
2392 * keeps a canonical cmd line, where prefix and white spaces are stripped off
2393 */
2394 trcBuf[0]='A';
2395 trcBuf[1]='T';
2396 if ((ledit_trace_line (src_id, &trcBuf[2])) EQ LEDIT_CMPL)
2397 {
2398 trace_cmd_line ("IN:", trcBuf,
2399 src_id,
2400 (USHORT)strlen(trcBuf));
2401 }
2402
2403 return (ati_execute_cmd_line (src_params));
2404 }
2405 case (LEDIT_FAIL): /* non valid command line */
2406 {
2407 TRACE_EVENT ("ati_execute_eval_rslt(): rv_ledit = LEDIT_FAIL");
2408 io_sendConfirm (src_params->src_id, cmdAtError(atError), ATI_ERROR_OUTPUT);
2409 cmdErrStr = NULL;
2410 return (ATI_FAIL);
2411 }
2412 case (LEDIT_ESC): /* if in text mode <ESC> was sent, then no error message, but an OK */
2413 {
2414 TRACE_EVENT("ati_execute_eval_rslt(): Send message command cancelled by user and catched by line edit");
2415 src_params->text_mode = CMD_MODE;
2416 first_prompt = FALSE;
2417
2418 if (ledit_ctrl(src_params->src_id,LEDIT_CTRL_MORE_CMDS, NULL) EQ LEDIT_CMPL)
2419 {
2420 /* <Esc> was sent, but there are further cmds */
2421 return (ati_execute_cmd_line (src_params));
2422 }
2423 else
2424 {
2425 ledit_ctrl (src_id,LEDIT_CTRL_CMPL, NULL);
2426 trace_cmd_state(src_params->src_id, src_params->cmd_state, CMD_IDLE);
2427 src_params->cmd_state = CMD_IDLE;
2428 io_sendConfirm (src_params->src_id, cmdAtError(atOk), ATI_NORMAL_OUTPUT);
2429 return (ATI_CMPL);
2430 }
2431 }
2432 case (LEDIT_COLLECT): /* line edit is (still) in COLLECT mode (both cmd/text mode) */
2433 {
2434 TRACE_EVENT ("ati_execute_eval_rslt(): rv_ledit = LEDIT_COLLECT");
2435 return (ATI_EXCT);
2436 }
2437 case (LEDIT_OK): /* line edit recognized a single <CR> or simple "AT<CR>", so emit an OK */
2438 {
2439 TRACE_EVENT ("ati_execute_eval_rslt(): rv_ledit = LEDIT_OK");
2440 io_sendConfirm (src_params->src_id, cmdAtError(atOk), ATI_NORMAL_OUTPUT);
2441 return (ATI_CMPL);
2442 }
2443 case (LEDIT_IGNORE): /* malberto will be interpreted as ato ;-) */
2444 {
2445 TRACE_EVENT ("ati_execute_eval_rslt(): rv_ledit = LEDIT_IGNORE");
2446 return (ATI_EXCT);
2447 }
2448 default:
2449 {
2450 TRACE_ERROR("ati_execute(): invalid state");
2451 return (ATI_FAIL);
2452 }
2453 } /* end of switch (rv_ledit) */
2454 }
2455
2456 /*
2457 +-------------------------------------------------------------------+
2458 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2459 | ROUTINE : ati_execute |
2460 +-------------------------------------------------------------------+
2461
2462 PURPOSE :
2463 */
2464 GLOBAL T_ATI_RSLT ati_execute (UBYTE src_id, UBYTE *chars, USHORT len)
2465 {
2466 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, src_id, search_ati_src_id);
2467
2468 T_LEDIT_ATCMD *cmd = NULL;
2469 T_LEDIT_ERR *err = NULL;
2470 T_LEDIT_RSLT rv_ledit = LEDIT_FAIL;
2471
2472 TRACE_FUNCTION ("ati_execute()");
2473
2474 if (src_params EQ NULL)
2475 {
2476 TRACE_EVENT ("[ERR] ati_execute: source ID not found");
2477 return (ATI_FAIL);
2478 }
2479
2480 /* Global variable srcId_cb is set with current source Id */
2481 srcId_cb = src_id;
2482
2483 /*
2484 * the source sent a char, chunk of chars or a complete AT command line,
2485 * so ATI is for this source in state CMD_TYPING
2486 */
2487 if (src_params->cmd_state EQ CMD_RUNNING)
2488 {
2489 ; /* keep CMD_RUNNING state for the second call of SMS-edit functions CMGW and CMGS in TEXT-Mode */
2490 }
2491 else /* trigger starting of new cmdline */
2492 {
2493 trace_cmd_state(src_params->src_id, src_params->cmd_state, CMD_TYPING);
2494 src_params->cmd_state = CMD_TYPING;
2495 }
2496
2497 /*
2498 * call line edit to pre process the command line
2499 */
2500 if (src_params->text_mode EQ CMD_MODE)
2501 {
2502 rv_ledit = ledit_cmd (src_id, chars, len);
2503 }
2504 else
2505 {
2506 rv_ledit = ledit_text (src_id, chars, len);
2507 }
2508 /*
2509 * echo the received characters when source has been set to echo,
2510 * but not for e.g.: the "mAlberTO" phenomenon --> ATO, where "m lber" are ignored
2511 */
2512 if ((ati_user_output_cfg[src_params->src_id].atE) AND (rv_ledit NEQ LEDIT_IGNORE))
2513 {
2514 /* if only '\b' is printed clean the current character */
2515 if ((g_ledit_echoBuf[0] EQ at.S[5]) AND (g_ledit_echoBuf[1] EQ '\0'))
2516 {
2517 char delseq[4];
2518 delseq[0]=at.S[5];
2519 delseq[1]=' ';
2520 delseq[2]=at.S[5];
2521 delseq[3]='\0';
2522 /* This will wipe current character from terminal */
2523 io_sendMessageEx (src_params->src_id, delseq, ATI_ECHO_OUTPUT);
2524 }
2525 else
2526 {
2527 io_sendMessageEx (src_params->src_id, g_ledit_echoBuf, ATI_ECHO_OUTPUT);
2528 }
2529 }
2530 /*
2531 * evaluate the result value of line edit and execute the cmd line
2532 */
2533 return (ati_execute_eval_rslt (src_id, src_params, rv_ledit));
2534 }
2535
2536
2537 /*
2538 +-------------------------------------------------------------------+
2539 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2540 | ROUTINE : init_ati |
2541 +-------------------------------------------------------------------+
2542
2543 PURPOSE :
2544 */
2545 GLOBAL void init_ati (void)
2546 {
2547 ati_src_list = new_list ();
2548 rEXT_Init();
2549 }
2550
2551 /*
2552 +-------------------------------------------------------------------+
2553 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2554 | ROUTINE : ati_init |
2555 +-------------------------------------------------------------------+
2556
2557 PURPOSE :
2558 */
2559 GLOBAL UBYTE ati_init (T_ATI_SRC_TYPE src_type,
2560 T_ATI_RESULT_CB *result_cb,
2561 T_ATI_LINE_STATE_CB *line_state_cb)
2562 {
2563 UBYTE src_id;
2564 T_ATI_SRC_PARAMS *src_params;
2565
2566 TRACE_FUNCTION ("ati_init ()");
2567
2568 src_id = aci_init (src_type);
2569 if (src_id EQ 0)
2570 {
2571 return (0);
2572 }
2573
2574 aci_cmd_src_mode_set(src_id,CMD_MODE_ATI);
2575
2576 #ifdef FF_ATI_BAT
2577 /* we use test or uart source as application and user of the BAT library */
2578 if ((src_type EQ ATI_SRC_TYPE_TST)
2579 OR (src_type EQ ATI_SRC_TYPE_UART))
2580 {
2581 if (ati_bat_globs.bat_lib_initialized EQ FALSE)
2582 {
2583 ati_bat_lib_init(src_id);
2584 }
2585 ati_bat_lib_new(src_id, src_type); /* one instance per ATI source */
2586 ati_bat_open_client(src_id); /* but only one client per instance */
2587 }
2588 #endif /* FF_ATI_BAT */
2589
2590 ACI_MALLOC (src_params, sizeof (T_ATI_SRC_PARAMS));
2591
2592 src_params->src_id = src_id;
2593 src_params->src_type = src_type;
2594 src_params->result_cb = result_cb;
2595 src_params->line_state_cb = line_state_cb;
2596 src_params->cmd_state = CMD_IDLE;
2597 src_params->buff_uns_mode = BUFF_RUNNING;
2598 src_params->indication_buffer = NULL;
2599 src_params->text_mode = CMD_MODE;
2600 src_params->curAtCmd = AT_CMD_NONE;
2601 src_params->mode = ATI_UNKN_MODE;
2602
2603 insert_list (ati_src_list, src_params);
2604
2605 return (src_id);
2606 }
2607
2608 /*
2609 +-------------------------------------------------------------------+
2610 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2611 | ROUTINE : ati_finit |
2612 +-------------------------------------------------------------------+
2613
2614 PURPOSE :
2615 */
2616 GLOBAL void ati_finit (UBYTE src_id)
2617 {
2618 T_ATI_SRC_PARAMS *src_params;
2619
2620 TRACE_EVENT_P1("ati_finit(): source: %d", src_id);
2621
2622 src_params = remove_element (ati_src_list, src_id, search_ati_src_id);
2623 if (src_params EQ NULL)
2624 {
2625 /* often seen with pei_exit() during simulation, because tries to close all sources,
2626 but there are not so many open */
2627 TRACE_EVENT_P1 ("ati_finit(): source: %d not found", src_id);
2628 return;
2629 }
2630
2631 ACI_MFREE (src_params);
2632
2633 aci_finit (src_id);
2634
2635 #ifdef FF_ATI_BAT
2636 ati_bat_close_client(src_id);
2637 if (ati_bat_all_clients_closed())
2638 {
2639 ati_bat_lib_finit();
2640 }
2641 #endif
2642 }
2643
2644
2645 /*
2646 +--------------------------------------------------------------------+
2647 | PROJECT: GSM-PS (6147) MODULE: ACI_CMD |
2648 | STATE : code ROUTINE: aci_timeout |
2649 +--------------------------------------------------------------------+
2650
2651 PURPOSE : A timeout has occured for a timer. The function returns
2652 TRUE, if it is a timer which is handled by ACI, else FALSE
2653 is returned to indicate that the timer has not been
2654 processed.
2655
2656 */
2657 UBYTE aci_timeout (USHORT index)
2658 {
2659 TRACE_FUNCTION ("aci_timeout()");
2660
2661 if (index EQ ACI_TRING)
2662 {
2663 /*
2664 * timeout ring timer
2665 */
2666 aciRingTimeout ();
2667 return TRUE;
2668 }
2669 if (index EQ ACI_CNMA_TIMER_HANDLE)
2670 {
2671 /*
2672 * timeout +CNMA waiting timer
2673 */
2674 aciCnmaTimeout();
2675 return TRUE;
2676 }
2677
2678 /*
2679 * the timeout is not for ACI
2680 */
2681 return FALSE;
2682 }
2683
2684 /*
2685 +--------------------------------------------------------------------+
2686 | PROJECT: GSM-PS (6147) MODULE: ACI_CMD |
2687 | STATE : code ROUTINE: aciRingTimeout |
2688 +--------------------------------------------------------------------+
2689
2690 PURPOSE : +CNMA timeout. Relay function for cmd_handleCnmaTimeout();
2691 */
2692 void aciCnmaTimeout( void )
2693 {
2694 cmd_handleCnmaTimeout();
2695 }
2696
2697
2698 /*
2699 +--------------------------------------------------------------------+
2700 | PROJECT: GSM-PS (6147) MODULE: ACI_CMD |
2701 | STATE : code ROUTINE: aciRingTimeout |
2702 +--------------------------------------------------------------------+
2703
2704 PURPOSE : Ring timeout. Check S0 register for automatic answer mode.
2705 Indicate ring and accept call if S0 value is reached
2706 */
2707 void aciRingTimeout ( void )
2708 {
2709 UBYTE idx;
2710
2711 TRACE_FUNCTION ("aciRingTimeout()");
2712
2713 /* indicate ringing */
2714 at.rngPrms.rngCnt++;
2715
2716 for (idx = 0; idx < CMD_SRC_MAX; idx++)
2717 {
2718 if ((idx NEQ CMD_SRC_LCL) AND IS_SRC_USED (idx))
2719 {
2720 srcId_cb = idx;
2721 if (!at.rngPrms.isRng) /* only handle the subsequent sources if ringing was not stopped */
2722 break;
2723 rCI_PlusCRING ( at.rngPrms.mode, at.rngPrms.type1, at.rngPrms.type2 );
2724
2725 #ifdef NO_ASCIIZ
2726 rCI_PlusCLIP ( at.clipPrms.stat, strlen(at.clipPrms.number)?(at.clipPrms.number):NULL, &at.clipPrms.type,
2727 at.clipPrms.validity, strlen(at.clipPrms.subaddr)?(at.clipPrms.subaddr):NULL,
2728 &at.clipPrms.satype, (at.clipPrms.alpha.len)?(&at.clipPrms.alpha):NULL );
2729 #else
2730 rCI_PlusCLIP ( at.clipPrms.stat, strlen(at.clipPrms.number)?(at.clipPrms.number):NULL, &at.clipPrms.type,
2731 at.clipPrms.validity, strlen(at.clipPrms.subaddr)?(at.clipPrms.subaddr):NULL,
2732 &at.clipPrms.satype, strlen(at.clipPrms.alpha)?(at.clipPrms.alpha):NULL );
2733 #endif
2734 }
2735 }
2736 }
2737
2738 /*
2739 +--------------------------------------------------------------------+
2740 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2741 | STATE : code ROUTINE : find_index |
2742 +--------------------------------------------------------------------+
2743
2744 PURPOSE : find index_function
2745
2746 */
2747 static SHORT find_index(CHAR * cl)
2748 {
2749 int i = 1;
2750
2751 while (cmds[i].key NEQ NULL)
2752 {
2753 if (strcmp (cl, cmds[i].key) EQ 0) /* command found */
2754 return (i);
2755
2756 i++;
2757 }
2758
2759 return (0);
2760 }
2761
2762 /*
2763 +-------------------------------------------------------------------+
2764 | PROJECT : GSM-PS (6147) MODULE : ATI |
2765 | STATE : code ROUTINE : ati_get_cmds_key |
2766 +-------------------------------------------------------------------+
2767
2768 PURPOSE : This function returns the cmd key "+CMD" from the command id
2769 */
2770
2771 GLOBAL void ati_get_cmds_key (T_ACI_AT_CMD cmd_id, CHAR **cmd_key, CHAR **testcmd_output)
2772 {
2773 int i = 1;
2774
2775 while (cmds[i].key NEQ NULL)
2776 {
2777 if (cmds[i].binKey EQ cmd_id) /* command found */
2778 {
2779 break;
2780 }
2781 i++;
2782 }
2783
2784 if (cmds[i].key EQ NULL)
2785 {
2786 TRACE_EVENT_P1("Command not found !!! cmd_id: %d", cmd_id);
2787 return;
2788 }
2789
2790 if (cmd_key NEQ NULL)
2791 {
2792 *cmd_key = cmds[i].key;
2793 }
2794
2795 if (testcmd_output NEQ NULL)
2796 {
2797 *testcmd_output = cmds[i].output1;
2798 }
2799 }
2800
2801 /*
2802 +--------------------------------------------------------------------+
2803 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2804 | STATE : code ROUTINE : resp_disp |
2805 +--------------------------------------------------------------------+
2806
2807 PURPOSE : display response
2808 */
2809
2810 GLOBAL CHAR *resp_disp (UBYTE srcId, CHAR *cl,CHAR *type, ...)
2811 /*types: "llsle..." b:BYTE l:LONG s:SHORT
2812 e:enum or int x: enum in X */
2813 {
2814 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
2815 va_list varpars; /* varpars not to be initialised as it is not scalar */
2816 USHORT i = 0;
2817 SHORT pos,
2818 buf_length,
2819 type_length = 0;
2820 CHAR *cmd_key = "";
2821
2822 if (type NEQ NULL)
2823 {
2824 type_length = strlen(type);
2825 }
2826
2827 va_start (varpars, type);
2828
2829 ati_get_cmds_key (src_params->curAtCmd, &cmd_key, NULL);
2830
2831 pos = sprintf (g_sa,"%s: ", cmd_key);
2832
2833 while ( i < type_length)
2834 {
2835 switch(*type)
2836 {
2837 case('b'):
2838 pos += sprintf(g_sa+pos,"%d,",*(va_arg (varpars,BYTE*)));
2839 break;
2840 case('e'):
2841 pos += sprintf(g_sa+pos,"%d,",*(va_arg (varpars,int*)));
2842 break;
2843 case('l'):
2844 pos += sprintf(g_sa+pos,"%d,",*(va_arg (varpars,LONG*)));
2845 break;
2846 case('s'):
2847 pos += sprintf(g_sa+pos,"%d,",*(va_arg (varpars,SHORT*)));
2848 break;
2849 case('x'):
2850 pos += sprintf(g_sa+pos,"%X,",*(va_arg (varpars,int*)));
2851 }
2852 i++;
2853 type++;
2854 }
2855 buf_length = strlen(g_sa);
2856 g_sa[buf_length - 1] = '\0'; /* to get rid of the last comma */
2857
2858 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
2859 va_end (varpars); /* Reset variable arguments. */
2860 return cl;
2861 }
2862
2863 /*
2864 +--------------------------------------------------------------------+
2865 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2866 | STATE : code ROUTINE : test_gen |
2867 +--------------------------------------------------------------------+
2868
2869 PURPOSE : generic test function
2870 */
2871
2872 static T_ATI_RSLT test_gen(CHAR * cl, UBYTE srcId)
2873 {
2874 CHAR *cmd_key = "";
2875 CHAR *testcmd_output = "";
2876 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
2877
2878 TRACE_FUNCTION("test_gen()");
2879
2880 ati_get_cmds_key (src_params->curAtCmd, &cmd_key, &testcmd_output);
2881
2882 if (testcmd_output NEQ NULL)
2883 {
2884 sprintf (g_sa, testcmd_output, cmd_key);
2885 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT);
2886 }
2887 return (ATI_CMPL);
2888 }
2889
2890 /*
2891 +--------------------------------------------------------------------+
2892 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2893 | STATE : code ROUTINE : atPlusCLAC |
2894 +--------------------------------------------------------------------+
2895
2896 PURPOSE : +CLAC command (List AT commands list)
2897 */
2898
2899 GLOBAL T_ATI_RSLT atPlusCLAC (char *cl, UBYTE srcId)
2900 {
2901 int i = 1 /*0*/; /* because of new cmds[] table */
2902 int j = 0;
2903
2904 TRACE_FUNCTION("atPlusCLAC()");
2905
2906 if ( *cl EQ '\0' OR *cl EQ ';' )
2907 {
2908 if ( *cl EQ ';' )
2909 cl++;
2910
2911 while (cmds[i].key NEQ NULL)
2912 {
2913 sprintf(g_sa,"AT%s",cmds[i].key);
2914 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
2915 i++;
2916 }
2917 for (;j<26;j++)
2918 {
2919 if (cmds_bas[j].key) /* Output if present */
2920 {
2921 sprintf(g_sa,"AT%s",cmds_bas[j].key);
2922 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
2923 }
2924 if (cmds_bas[j].and_key) /* Output if present */
2925 {
2926 sprintf(g_sa,"AT%s",cmds_bas[j].and_key);
2927 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
2928 }
2929 }
2930 }
2931 else
2932 {
2933 cmdCmeError (CME_ERR_OpNotSupp);
2934 return (ATI_FAIL);
2935 }
2936
2937 return (ATI_CMPL);
2938 }
2939
2940
2941
2942 /*
2943 +--------------------------------------------------------------------+
2944 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2945 | STATE : code ROUTINE : atPlusGCI |
2946 +--------------------------------------------------------------------+
2947
2948 PURPOSE : +GCI command (manufacturer identification)
2949 */
2950
2951 GLOBAL T_ATI_RSLT setatPlusGCI(char *cl, UBYTE srcId)
2952 {
2953 T_ACI_RETURN ret;
2954 UBYTE country; /* check if long enough */
2955 SHORT pos=0;
2956
2957 TRACE_FUNCTION("setatPlusGCI()");
2958
2959 switch (*cl)
2960 {
2961 case('='):
2962 {
2963 cl++;
2964 cl=parse(cl,"h",&country);
2965 if(!cl)/*OR country > 0xff) this expression always returns false (LINT)*/
2966 {
2967 cmdAtError(atError);
2968 return (ATI_FAIL);
2969 }
2970 ret = sAT_PlusGCI(srcId ,country);
2971 break;
2972 }
2973 default:
2974 {
2975 cmdAtError(atError);
2976 return (ATI_FAIL);
2977 }
2978 }
2979 if (ret EQ AT_FAIL)
2980 {
2981 cmdAtError(atError);
2982 return (ATI_FAIL);
2983 }
2984 return (ATI_CMPL);
2985 }
2986
2987 GLOBAL T_ATI_RSLT queatPlusGCI(char *cl, UBYTE srcId)
2988 {
2989 T_ACI_RETURN ret;
2990 UBYTE country; /* check if long enough */
2991 SHORT pos=0;
2992
2993 TRACE_FUNCTION("atPlusGCI()");
2994
2995 ret=qAT_PlusGCI(srcId,&country);
2996 if (ret EQ AT_CMPL)
2997 {
2998 pos=sprintf(g_sa,"+GCI:%02X",country);
2999 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
3000 return (ATI_CMPL);
3001 }
3002 else
3003 {
3004 cmdAtError(atError);
3005 return (ATI_FAIL);
3006 }
3007 }
3008
3009 /*
3010 +--------------------------------------------------------------------+
3011 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3012 | STATE : code ROUTINE : atPlusCCWE |
3013 +--------------------------------------------------------------------+
3014
3015 PURPOSE : +CCWE Call Meter Maximum Event
3016 */
3017
3018 GLOBAL T_ATI_RSLT setatPlusCCWE(char *cl, UBYTE srcId)
3019 {
3020 SHORT mode = ACI_NumParmNotPresent;
3021
3022 TRACE_FUNCTION ( "setatPlusCCWE()" );
3023
3024 cl = parse ( cl, "d", &mode );
3025 if ( !cl OR mode > 1 OR mode < 0 )
3026 {
3027 cmdCmeError ( CME_ERR_OpNotAllow );
3028 return (ATI_FAIL);
3029 }
3030
3031 ati_user_output_cfg[srcId].CCWE_stat = ( UBYTE ) mode;
3032 return (ATI_CMPL);
3033 }
3034
3035
3036 GLOBAL T_ATI_RSLT queatPlusCCWE(char *cl, UBYTE srcId)
3037 {
3038 TRACE_FUNCTION ( "queatPlusCCWE()" );
3039
3040 resp_disp(srcId, cl,"b",&ati_user_output_cfg[srcId].CCWE_stat);
3041 return (ATI_CMPL);
3042 }
3043
3044 /*
3045 +--------------------------------------------------------------------+
3046 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3047 | STATE : code ROUTINE : aci_sendPString |
3048 +--------------------------------------------------------------------+
3049
3050 PURPOSE : This function is used to send a PASCAL like string to
3051 the serial interface.
3052 */
3053 GLOBAL void aci_sendPString (UBYTE srcId, CHAR* buffer)
3054 {
3055 UBYTE nextLen;
3056 UBYTE actLen;
3057
3058 TRACE_FUNCTION ( "aci_sendPString ()" );
3059
3060 nextLen = buffer[0];
3061
3062 while ( nextLen NEQ ACI_EXT_STRG_END)
3063 {
3064 actLen = nextLen;
3065 nextLen = buffer[actLen + 1];
3066 buffer[actLen + 1] = '\0';
3067
3068 io_sendMessage ( srcId, &buffer[1], ATI_NORMAL_OUTPUT );
3069
3070 buffer[actLen + 1] = (CHAR)nextLen;
3071
3072 buffer = &buffer[actLen + 1];
3073 }
3074 }
3075
3076 /*
3077 +--------------------------------------------------------------------+
3078 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3079 | STATE : code ROUTINE : sAT_CfgEXT |
3080 +--------------------------------------------------------------------+
3081
3082 PURPOSE : This function is used to store the list of AT command
3083 which are forwarded to the AT command extension module
3084 in case mobile is not registered (neither limited nor
3085 full service is available).
3086 */
3087 GLOBAL T_ACI_RETURN sAT_CfgEXT ( CHAR** fwrdLst )
3088 {
3089 TRACE_FUNCTION ( "sAT_CfgEXT ()" );
3090
3091 atCmdFwrdLst = fwrdLst;
3092
3093 return ( AT_CMPL );
3094 }
3095
3096 /*
3097 +--------------------------------------------------------------------+
3098 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3099 | STATE : code ROUTINE : aci_SrchFwrdLst |
3100 +--------------------------------------------------------------------+
3101 PURPOSE : This function is used to search for a specific string in
3102 the list of AT commands which will be forwarded if
3103 necessary.
3104 */
3105 LOCAL BOOL aci_SrchFwrdLst ( UBYTE srcId, CHAR* searchFor )
3106 {
3107 CHAR** pTmp;
3108 int i=0;
3109
3110 TRACE_FUNCTION ( "aci_SrchFwrdLst ()" );
3111
3112 if (ext_v2_flag EQ TRUE)
3113 {
3114 TRACE_EVENT ("New Extension Mechanism...");
3115 pTmp = atCmdFwrdLst_v2;
3116 }
3117 else
3118 {
3119 TRACE_EVENT ("Old Extension Mechanism...");
3120 pTmp = atCmdFwrdLst;
3121 }
3122
3123 if (pTmp)
3124 {
3125 while (*(pTmp+i) NEQ NULL)
3126 {
3127 if ( strcmp ( *(pTmp+i), searchFor ) EQ 0 )
3128 {
3129 TRACE_EVENT_P1 ( "aci_SrchFwrdLst(): %s found", searchFor);
3130 return TRUE;
3131 }
3132 i++;
3133 }
3134 }
3135 else
3136 {
3137 TRACE_EVENT( "aci_SrchFwrdLst(): atCmdFwrdLst does not exist");
3138 }
3139 return FALSE;
3140 }
3141 /*
3142 +--------------------------------------------------------------------+
3143 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3144 | STATE : code ROUTINE : aci_FwrdToEXT |
3145 +--------------------------------------------------------------------+
3146
3147 PURPOSE : This function is used to forward an AT command to the
3148 extension handler.
3149 */
3150 LOCAL T_ATI_RSLT aci_FwrdToEXT (T_ATI_SRC_PARAMS *src_params, T_LEDIT_ATCMD *cmd)
3151 {
3152 USHORT lenExt = 0;
3153 char *extCmd = NULL;
3154 T_ACI_RETURN extRslt = AT_FAIL;
3155
3156 TRACE_FUNCTION ( "aci_FwrdToEXT ()" );
3157
3158 ACI_MALLOC(extCmd, MAX_CMD_LEN);
3159 *extCmd = '\0';
3160
3161 if (src_id_ext NEQ 0xFF)
3162 {
3163 TRACE_EVENT("aci_FwrdToEXT(): src_id_ext has not been reset to 0xFF");
3164 }
3165
3166 /*
3167 * only this source can currently run extension commands
3168 * the reset to 0xFF takes place in ati_run_cmd_line() and rCI_PlusCME() (asynchronious case)
3169 */
3170 src_id_ext = src_params->src_id;
3171 /*
3172 * we have to build up the extension cmd in the same old manner before using of line edit
3173 */
3174 /* All sprintfs below are now replaced by strcats . Bug 18239 */
3175
3176 if(cmd->type.append_Flag EQ TRUE)
3177 {
3178 switch(cmd->type.sType)
3179 {
3180 case LEDIT_ATCMD_SET :
3181 {
3182 if ((strlen(cmd->params)) NEQ 0)
3183 {
3184 strcat(extCmd,cmd->name);
3185 strcat(extCmd,"=");
3186 strcat(extCmd,cmd->params);
3187 }
3188 else
3189 {
3190 strcat(extCmd,cmd->name);
3191 }
3192 break;
3193 }
3194
3195 case LEDIT_ATCMD_QUERY :
3196 {
3197 if ((strlen(cmd->params)) NEQ 0)
3198 {
3199 strcat(extCmd,cmd->name);
3200 strcat(extCmd,"?");
3201 strcat(extCmd,cmd->params);
3202 }
3203 else
3204 {
3205 strcat(extCmd,cmd->name);
3206 strcat(extCmd,"?");
3207 }
3208 break;
3209 }
3210
3211 case LEDIT_ATCMD_TEST:
3212 {
3213 if ((strlen(cmd->params)) NEQ 0)
3214 {
3215 strcat(extCmd,cmd->name);
3216 strcat(extCmd,"=");
3217 strcat(extCmd,"?");
3218 strcat(extCmd,cmd->params);
3219 }
3220 else
3221 {
3222 strcat(extCmd,cmd->name);
3223 strcat(extCmd,"=");
3224 strcat(extCmd,"?");
3225 }
3226 break;
3227 }
3228 }
3229 }
3230
3231 if(cmd->type.append_Flag EQ FALSE)
3232 {
3233 switch(cmd->type.sType)
3234 {
3235 case LEDIT_ATCMD_SET:
3236 case LEDIT_ATCMD_QUERY:
3237 case LEDIT_ATCMD_TEST:
3238 {
3239 strcat(extCmd,cmd->name);
3240 break;
3241 }
3242 default:
3243 {
3244 strcat(extCmd,cmd->name);
3245 break;
3246 }
3247 }
3248 }
3249
3250 lenExt = strlen(extCmd);
3251 TRACE_EVENT_P1("aci_FwrdToEXT(): Total Command Length %x ", lenExt);
3252
3253 if (strchr (OLD_NON_STANDARDIZED_ATCMD, extCmd[0]))
3254 {
3255 if (*extCmd EQ '&')
3256 {
3257 if (strchr (OLD_NON_STANDARDIZED_ATCMD, extCmd[1]) EQ NULL)
3258 {
3259 TRACE_EVENT("[ERR]aci_FwrdToEXT ()");
3260 cmdAtError (atError);
3261 ACI_MFREE(extCmd);
3262 return (ATI_FAIL);
3263 }
3264 }
3265 }
3266
3267 send_output_type_signal (src_params, ATI_OUTPUT_TYPE_NORMAL);
3268
3269 g_sa[0] = (CHAR) ACI_EXT_STRG_END;
3270
3271 TRACE_EVENT_P1("aci_FwrdToEXT(): running cmd %s", extCmd);
3272 if (ext_v2_flag EQ TRUE)
3273 {
3274 extRslt = rEXT_Execute (src_params->src_id, extCmd);
3275 }
3276 else
3277 {
3278 extRslt = rAT_EXT (extCmd, &lenExt, g_sa, MAX_CMD_LEN - 1);
3279 aci_sendPString (src_params->src_id, g_sa);
3280 }
3281
3282 ACI_MFREE(extCmd);
3283
3284 switch (extRslt)
3285 {
3286 case (AT_CMPL):
3287 {
3288 cmdErrStr = NULL;
3289 TRACE_EVENT("aci_FwrdToEXT(): returns with ATI_CMPL");
3290 return (ATI_CMPL);
3291 }
3292 case (AT_EXCT):
3293 {
3294 cmdErrStr = NULL;
3295 src_params->curAtCmd = AT_CMD_EXT;
3296 TRACE_EVENT("aci_FwrdToEXT(): returns with ATI_EXCT");
3297 return (ATI_EXCT);
3298 }
3299
3300 default:
3301 {
3302 cmdAtError (atError);
3303 TRACE_EVENT("aci_FwrdToEXT(): returns with ATI_FAIL");
3304 return (ATI_FAIL);
3305 }
3306 }
3307 }
3308
3309 /*
3310 +--------------------------------------------------------------------+
3311 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3312 | STATE : code ROUTINE : aci_cmhActive |
3313 +--------------------------------------------------------------------+
3314
3315 PURPOSE : This function is used to calculate whether the mobile is
3316 in service.
3317 */
3318 LOCAL BOOL aci_cmhActive ( UBYTE srcId )
3319 {
3320 BOOL rslt = FALSE;
3321 T_ACI_NRG_RGMD regMode;
3322 T_ACI_NRG_SVMD srvMode;
3323 T_ACI_NRG_FRMT oprFrmt;
3324 T_ACI_NRG_SVMD srvStat;
3325 CHAR oper[MAX_ALPHA_OPER_LEN];
3326
3327 TRACE_FUNCTION ( "aci_cmhActive ()" );
3328
3329 qAT_PercentNRG( srcId,
3330 &regMode,
3331 &srvMode,
3332 &oprFrmt,
3333 &srvStat,
3334 oper);
3335
3336 if ( srvStat EQ NRG_SVMD_Full OR
3337 srvStat EQ NRG_SVMD_Limited )
3338 {
3339 rslt = TRUE;
3340 }
3341
3342 return rslt;
3343 }
3344
3345 /*
3346 +--------------------------------------------------------------------+
3347 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3348 | STATE : code ROUTINE : ati_switch_mode |
3349 +--------------------------------------------------------------------+
3350
3351 PURPOSE : changes mode from command mode to data mode and vice-versa.
3352
3353 */
3354
3355 GLOBAL void ati_switch_mode (UBYTE srcId,
3356 T_ATI_IO_MODE mode)
3357 {
3358 T_ATI_SRC_PARAMS *src_params;
3359
3360 src_params = find_element (ati_src_list, srcId, search_ati_src_id);
3361 if (src_params EQ NULL)
3362 {
3363 TRACE_EVENT_P1 ("[ERR] io_sendMessage: srcId=%d not found", srcId);
3364 return;
3365 }
3366
3367 src_params->mode = mode;
3368
3369 if (mode EQ ATI_CMD_MODE)
3370 {
3371 TRACE_EVENT("IO mode changed to CMD MODE");
3372 cmd_flushCievBuf(src_params->src_id);
3373
3374 /* The CNMI buffer is flushed only if the current source
3375 * matches with the source interested in SMS indications */ /* Issue 25033 */
3376 if ( src_params->src_id EQ smsShrdPrm.smsSrcId )
3377 {
3378 /* If Service is not GSM phase 2+, flushing is done at once,
3379 because acknowledge is not necessary */
3380 if( smsShrdPrm.CSMSservice NEQ CSMS_SERV_GsmPh2Plus )
3381 {
3382 cmd_flushCnmiBuf();
3383 }
3384 else
3385 {
3386 cmd_flushCnmiBufOneByOne();
3387 }
3388 }
3389 }
3390 else
3391 {
3392 TRACE_EVENT("IO mode changed to DATA MODE");
3393 }
3394 }
3395
3396
3397 /*
3398 +--------------------------------------------------------------------+
3399 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3400 | STATE : code ROUTINE : ati_get_mode |
3401 +--------------------------------------------------------------------+
3402
3403 PURPOSE : returns current IO-mode
3404 */
3405 GLOBAL T_ATI_IO_MODE ati_get_mode( UBYTE srcId )
3406 {
3407 T_ATI_SRC_PARAMS *src_params;
3408
3409 src_params = find_element (ati_src_list, srcId, search_ati_src_id);
3410 if (src_params EQ NULL)
3411 {
3412 TRACE_EVENT_P1 ("[ERR] io_sendMessage: srcId=%d not found", srcId);
3413 return ATI_UNKN_MODE;
3414 }
3415
3416 return( src_params->mode );
3417 }
3418
3419 /*
3420 +--------------------------------------------------------------------+
3421 | PROJECT : GSM-PS MODULE : ATI_IO |
3422 | STATE : code ROUTINE : format |
3423 +--------------------------------------------------------------------+
3424
3425 PURPOSE : format the ouput
3426
3427 */
3428
3429 GLOBAL USHORT format_output (UBYTE *src, USHORT src_len, UBYTE *dst,
3430 T_ATI_OUTPUT_TYPE output_type)
3431 {
3432 USHORT dst_len = 0;
3433
3434 if (at.s1415.atV)
3435 {
3436 /*
3437 * verbose mode
3438 */
3439 if (IS_BEGIN_CRLF_OUTPUT (output_type))
3440 {
3441 dst[0] = at.S[3];
3442 dst_len++;
3443 dst[1] = at.S[4];
3444 dst_len++;
3445 }
3446
3447 memcpy (dst + dst_len, src, src_len);
3448 dst_len += src_len;
3449
3450 if (IS_END_CRLF_OUTPUT (output_type))
3451 {
3452 dst[dst_len] = at.S[3];
3453 dst_len++;
3454 dst[dst_len] = at.S[4];
3455 dst_len++;
3456 }
3457
3458 return (dst_len);
3459 }
3460
3461 /*
3462 * non-verbose mode
3463 */
3464
3465 memcpy (dst + dst_len, src, src_len);
3466 dst_len += src_len;
3467
3468 if (IS_ECHO_OUTPUT (output_type))
3469 {
3470 return (dst_len);
3471 }
3472
3473 dst[dst_len] = at.S[3];
3474 dst_len++;
3475
3476 if (!(IS_CONFIRM_OUTPUT(output_type) OR IS_RESULT_CODE_OUTPUT(output_type)))
3477 {
3478 dst[dst_len] = at.S[4];
3479 dst_len++;
3480 }
3481
3482 return (dst_len);
3483 }
3484
3485 /*
3486 +--------------------------------------------------------------------+
3487 | PROJECT : GSM MODULE : ATI_RET |
3488 | STATE : code ROUTINE : ati_is_src_type |
3489 +--------------------------------------------------------------------+
3490
3491 PURPOSE : this function checks if the given source ID is of given type
3492 (example: is it a SAT source (for RUN AT COMMAND)
3493 */
3494
3495 GLOBAL BOOL ati_is_src_type( UBYTE srcId, T_ATI_SRC_TYPE source_type )
3496 {
3497 #ifdef SIM_TOOLKIT
3498 T_ATI_SRC_PARAMS *src_params;
3499 #endif /* SIM_TOOLKIT */
3500
3501 if (!IS_SRC_USED(srcId))
3502 {
3503 return(FALSE);
3504 }
3505
3506 #ifdef SIM_TOOLKIT
3507 src_params = find_element (ati_src_list, srcId, search_ati_src_id);
3508 if (src_params EQ NULL)
3509 {
3510 return FALSE;
3511 }
3512
3513 if( src_params->src_type EQ source_type )
3514 {
3515 TRACE_EVENT_P2("source %d is of type %d", srcId, source_type);
3516 return( TRUE );
3517 }
3518 else
3519 #endif /* SIM_TOOLKIT */ /* always returns FALSE if SIM_TOOLKIT isn't defined */
3520 {
3521 return( FALSE );
3522 }
3523 }
3524
3525
3526 /*
3527 PURPOSE :This function takes in the AT command string as input parameter and
3528 returns the corresponding command ID. This function provides an interface for
3529 get_command_id_in_wn_list () to get the command Id from a local table cmd[ ]
3530 with a command name string as input.
3531 */
3532
3533 GLOBAL T_ACI_AT_CMD get_command_id (CHAR *command_str)
3534 {
3535 int i;
3536 T_ACI_AT_CMD command = AT_CMD_NONE;
3537
3538 TRACE_FUNCTION ("get_command_id()");
3539
3540 for (i = 1; cmds [i].key NEQ NULL AND strcmp (cmds [i].key, command_str); i ++) { }
3541 command = cmds [i].binKey;
3542 TRACE_EVENT_P1 ("command Id is: %d", command);
3543 return (command);
3544 }
3545
3546 /*
3547 +--------------------------------------------------------------------+
3548 | PROJECT : GSM MODULE : ATI_CMD |
3549 | STATE : code ROUTINE : sEXT_Output |
3550 +--------------------------------------------------------------------+
3551
3552 PURPOSE : this function provides the interface for the extension mechanism to output
3553 messages to the source. If the message is too long the calling function can
3554 seperate the message into several parts and choose the right output type.
3555 */
3556
3557 GLOBAL T_ATI_RSLT sEXT_Output (UBYTE src_id, T_ATI_EXT_FORMAT output_format,
3558 CHAR *output)
3559 {
3560 T_ATI_SRC_PARAMS *src_params;
3561
3562 TRACE_FUNCTION ("sEXT_Output()");
3563 src_params = find_element (ati_src_list, src_id, search_ati_src_id);
3564 if (src_params EQ NULL)
3565 {
3566 TRACE_EVENT_P1 ("[ERR] sEXT_Output: srcId=%d not found", src_id);
3567 return ATI_FAIL;
3568 }
3569 /* if (src_id NEQ src_id_ext)
3570 {
3571 TRACE_EVENT ("[ERR] sEXT_Output: No extension command running.");
3572 return ATI_FAIL;
3573 } */
3574 switch (output_format)
3575 {
3576 case ATI_EXT_PART_BEGIN:
3577 io_sendMessageEx(src_id, output, ATI_NORMAL_OUTPUT|ATI_BEGIN_CRLF_OUTPUT );
3578 break;
3579 case ATI_EXT_PART_LAST:
3580 io_sendMessageEx(src_id, output, ATI_NORMAL_OUTPUT|ATI_END_CRLF_OUTPUT );
3581 break;
3582 case ATI_EXT_PART_LINE:
3583 io_sendMessageEx(src_id, output, ATI_NORMAL_OUTPUT);
3584 break;
3585 case ATI_EXT_CMPL_LINE:
3586 io_sendMessageEx(src_id, output, ATI_NORMAL_OUTPUT|ATI_END_CRLF_OUTPUT );
3587 break;
3588 default:
3589 return ATI_FAIL;
3590 }
3591 return ATI_CMPL;
3592 }
3593
3594
3595 /*
3596 +--------------------------------------------------------------------+
3597 | PROJECT : GSM MODULE : ATI_CMD |
3598 | STATE : code ROUTINE : sEXT_Indication |
3599 +--------------------------------------------------------------------+
3600
3601 PURPOSE : this function provides the interface for the extension mechanism to output
3602 indications (unsolistic output) to the source.
3603 */
3604
3605 GLOBAL T_ATI_RSLT sEXT_Indication (UBYTE src_id, CHAR *indication_string)
3606 {
3607 TRACE_FUNCTION ("sEXT_Indication()");
3608 if (indication_string EQ NULL)
3609 {
3610 TRACE_EVENT ("[ERR] sEXT_Indication: No indication string.");
3611 return ATI_FAIL;
3612 }
3613 if (src_id NEQ src_id_ext)
3614 {
3615 TRACE_EVENT ("[ERR] sEXT_Indication: No extension command is running.");
3616 return ATI_FAIL;
3617 }
3618 io_sendIndication(src_id, indication_string, ATI_FORCED_OUTPUT);
3619 return AT_CMPL;
3620 }
3621
3622 /*
3623 +--------------------------------------------------------------------+
3624 | PROJECT : GSM MODULE : ATI_CMD |
3625 | STATE : code ROUTINE : sEXT_Confirm |
3626 +--------------------------------------------------------------------+
3627
3628 PURPOSE : this function provides the interface for the extension mechanism to output
3629 a confirmations to the source. A confirmation should be sent in the cases
3630 where an AT command runs for a long time and only ATI_EXT_EXCT has
3631 been returned.
3632 */
3633 GLOBAL T_ATI_RSLT sEXT_Confirm (UBYTE src_id)
3634 {
3635 T_ATI_SRC_PARAMS *src_params;
3636 TRACE_FUNCTION ("sEXT_Confirm()");
3637
3638 src_params = find_element (ati_src_list, src_id, search_ati_src_id);
3639 if (src_params EQ NULL)
3640 {
3641 TRACE_EVENT_P1 ("[ERR] sEXT_Confirm: srcId=%d not found", src_id);
3642 return ATI_FAIL;
3643 }
3644 if (src_id NEQ src_id_ext)
3645 {
3646 TRACE_EVENT ("[ERR] sEXT_Confirm: No extension command running.");
3647 return ATI_FAIL;
3648 }
3649 TRACE_EVENT("Extension command signals a successful result.") ;
3650 srcId_cb = src_id;
3651 rCI_OK (AT_CMD_EXT);
3652 return ATI_CMPL;
3653 }
3654
3655 /*
3656 +--------------------------------------------------------------------+
3657 | PROJECT : GSM MODULE : ATI_CMD |
3658 | STATE : code ROUTINE : sEXT_Error |
3659 +--------------------------------------------------------------------+
3660
3661 PURPOSE : this function provides the interface for the extension mechanism to output
3662 an error message to the source. An error message should be sent in the
3663 cases where error happens or when an AT command runs for a long time
3664 and only ATI_EXT_EXCT has been returned before an error happens. By
3665 calling this function the AT interpreter will be freed to run a second command.
3666 */
3667 GLOBAL T_ATI_RSLT sEXT_Error (UBYTE src_id, T_ACI_CME_ERR err)
3668 {
3669 TRACE_FUNCTION ("sEXT_Error()");
3670 if (src_id NEQ src_id_ext)
3671 {
3672 TRACE_EVENT ("[ERR] sEXT_Error: No extension command running.");
3673 return ATI_FAIL;
3674 }
3675 srcId_cb = src_id;
3676 rCI_PlusCME (AT_CMD_EXT, err);
3677 return ATI_CMPL;
3678 }
3679
3680 /*
3681 +--------------------------------------------------------------------+
3682 | PROJECT : GSM MODULE : ATI_CMD |
3683 | STATE : code ROUTINE : sEXT_Init |
3684 +--------------------------------------------------------------------+
3685
3686 PURPOSE : this function provides the interface for the extension mechanism
3687 */
3688 GLOBAL T_ATI_RSLT sEXT_Init (CHAR *cmd_list[])
3689 {
3690 TRACE_FUNCTION("sEXT_Init()");
3691 if (*cmd_list EQ NULL)
3692 {
3693 TRACE_EVENT ("The old EXT mechanism will be used.");
3694 ext_v2_flag = FALSE;
3695 }
3696 else
3697 {
3698 TRACE_EVENT ("The new EXT mechanism will be used.");
3699 ext_v2_flag = TRUE;
3700 atCmdFwrdLst_v2 = cmd_list;
3701 }
3702 return ATI_CMPL;
3703 }
3704
3705 /*
3706 +--------------------------------------------------------------------+
3707 | PROJECT : GSM MODULE : ATI_CMD |
3708 | STATE : code ROUTINE : sEXT_finit |
3709 +--------------------------------------------------------------------+
3710
3711 PURPOSE : this function frees the memory of the extension command list
3712
3713 GLOBAL T_ATI_RSLT sEXT_Finit ()
3714 {
3715 ACI_MFREE(atCmdFwrdLst);
3716 return ATI_CMPL;
3717 }*/
3718 #endif /* ATI_CMD_C */
3719