FreeCalypso > hg > fc-magnetite

comparison src/aci2/aci/ati_cmd.c @ 3:93999a60b835

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/aci2, src/condat2: import of g23m/condat source pieces from TCS211
author Mychaela Falconia <falcon@freecalypso.org>
date Mon, 26 Sep 2016 00:29:36 +0000
parents
children b16d79c550a2
comparison
equal deleted inserted replaced
2:c41a534f33c6 3:93999a60b835
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 #if 1 //CONFIG_AT_RVTMUX
1352 ati_src_rvt_register();
1353 #endif
1354
1355 cmd_clearCnmiBuf ();
1356
1357 /* for ATI parameters that are source dependant */
1358 for(i=0;i<CMD_SRC_MAX;i++)
1359 {
1360 ati_cmd_init_each_source( i );
1361 #ifdef GPRS
1362 gaci_ati_cmd_init_each_source( i );
1363 #endif /* GPRS */
1364 }
1365 }
1366
1367 /*
1368 +--------------------------------------------------------------------+
1369 | PROJECT : GSM-F&D (8411) MODULE : ATI_CMD |
1370 | STATE : code ROUTINE : ati_cmd_reset |
1371 +--------------------------------------------------------------------+
1372
1373 PURPOSE : sets ATI command Parameter to default values
1374
1375 */
1376
1377 GLOBAL void ati_cmd_reset(UBYTE srcId)
1378 {
1379 TRACE_FUNCTION ("ati_cmd_reset()");
1380
1381 at.S[0]=0; /* no auto answer when ring*/
1382 at.S[1]=0; /* holds the number of ring counts */
1383 at.S[3]=13;
1384 at.S[4]=10;
1385 at.S[5]=8;
1386 at.S[6]=2;
1387 at.S[7]=60;
1388 at.S[8]=2;
1389 at.S[10]=1;
1390 at.S30=1;
1391 #ifdef GPRS
1392 at.S99=1; /* automatic reject network initiated context prior the n-th ring */
1393 #endif /* GPRS */
1394 at.s1415.atM=0; /* Monitor Speaker Mode OFF */
1395 at.s1415.atL=0; /* Monitor Speaker Loudness LOW */
1396 at.s1415.atV=1; /* DCE Response Format:
1397 DCE transmits full headers and trailers
1398 and verbose response text.
1399 */
1400 at.flags.COLP_stat = 0;
1401 at.flags.CCWA_stat = 0;
1402 at.flags.CCBS_stat = 0;
1403
1404 ati_cmd_init_each_source(srcId);
1405 #ifdef GPRS
1406 gaci_ati_cmd_init_each_source(srcId);
1407 #endif /* GPRS */
1408 }
1409
1410 /*
1411 +--------------------------------------------------------------------+
1412 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1413 | STATE : code ROUTINE : compact |
1414 +--------------------------------------------------------------------+
1415
1416 PURPOSE : eliminates whitspaces in commandline
1417
1418 */
1419
1420 GLOBAL USHORT compact (char *s, USHORT len)
1421 {
1422 char *pWrite = s;
1423 char *pRead = s;
1424 BOOL isString = FALSE;
1425
1426 while ( pRead - s < len )
1427 {
1428 if (*pRead EQ '"')
1429 isString = !isString;
1430
1431 if (isString OR *pRead > ' ')
1432 *pWrite++ = *pRead;
1433
1434 pRead++;
1435 }
1436
1437 *pWrite = '\0';
1438
1439 return ( pWrite - s );
1440 }
1441
1442
1443 /*
1444 +--------------------------------------------------------------------+
1445 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1446 | STATE : code ROUTINE : rise |
1447 +--------------------------------------------------------------------+
1448
1449 PURPOSE : changes commands only to upper
1450
1451 */
1452 GLOBAL void rise(char *s, USHORT len)
1453 {
1454 char* begin = s;
1455
1456 while (s - begin < len)
1457 {
1458 if (*s EQ '"')
1459 {
1460 do
1461 {
1462 s++;
1463 } while(s - begin < len AND *s !='"');
1464 }
1465 else
1466 *s=toupper(*s);
1467 s++;
1468 }
1469 }
1470
1471 /*
1472 +--------------------------------------------------------------------+
1473 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1474 | STATE : code ROUTINE : check_str |
1475 +--------------------------------------------------------------------+
1476
1477 PURPOSE : checks given string if characters appear that shouldn't be in the string
1478
1479 */
1480
1481 GLOBAL BOOL check_str(char * string,char * sample)
1482 {
1483 for ( ; *string; string++)
1484 {
1485 if (!strchr(sample, *string))
1486 return FALSE;
1487 }
1488 return TRUE;
1489 }
1490
1491
1492 /*
1493 +--------------------------------------------------------------------+
1494 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1495 | STATE : code ROUTINE : toa_demerge |
1496 +--------------------------------------------------------------------+
1497
1498 PURPOSE : splits TOA octet into TOA structure
1499
1500 */
1501
1502 GLOBAL T_ACI_TOA toa_demerge (SHORT type)
1503 {
1504 T_ACI_TOA toa;
1505
1506 toa.ton = (type & 0x70)>>4;
1507 switch (toa.ton) /*valid values 0-4*/
1508 {
1509 // case TON_NotPresent : // =-1,
1510 case TON_Unknown : // = 0,
1511 case TON_International:
1512 case TON_National :
1513 case TON_NetSpecific :
1514 case TON_DedAccess :
1515 // case TON_Alphanumeric :
1516 // case TON_Abbreviated :
1517 // case TON_Extended : // ffs */
1518 break;
1519
1520 default:
1521 toa.ton = TON_NotPresent;
1522 break;
1523 }
1524
1525 toa.npi = type & 0xF;
1526 switch (toa.npi) /*valid values 0,1,3,4,8,9*/
1527 {
1528 // case NPI_NotPresent : // =-1,
1529 case NPI_Unknown : // = 0,
1530 case NPI_IsdnTelephony: // = 1,
1531 case NPI_Data : // = 3,
1532 case NPI_Telex : // = 4,
1533 case NPI_National : // = 8,
1534 case NPI_Private : // = 9,
1535 // case NPI_ERMES : // = 10, // ffs
1536 // case NPI_CTS : // = 11 // ffs
1537 break;
1538
1539 default:
1540 toa.npi = NPI_NotPresent;
1541 break;
1542 }
1543
1544 return toa;
1545 }
1546
1547 /*
1548 +--------------------------------------------------------------------+
1549 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1550 | STATE : code ROUTINE : tos_merge |
1551 +--------------------------------------------------------------------+
1552
1553 PURPOSE : builds type of sub-address octet from TOS structure
1554
1555 */
1556 GLOBAL SHORT tos_merge (T_ACI_TOS satype)
1557 {
1558 return ((satype.tos << 4) & 0x70)
1559 | ((satype.oe << 3) & 0x08)
1560 | 0x80;
1561 }
1562
1563 /*
1564 +--------------------------------------------------------------------+
1565 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1566 | STATE : code ROUTINE : tos_demerge |
1567 +--------------------------------------------------------------------+
1568
1569 PURPOSE : splits TOS structure into TOS structure
1570
1571 */
1572 GLOBAL T_ACI_TOS tos_demerge (SHORT tsatype)
1573 {
1574 T_ACI_TOS satype;
1575
1576 satype.tos = (tsatype & 0x70) >> 4;
1577 switch(satype.tos) /*valid values 0,2*/
1578 {
1579 // case TOS_NotPresent:// =-1,
1580 case TOS_Nsap :// = 0,
1581 case TOS_User :// = 2
1582 break;
1583
1584 default:
1585 satype.tos = TOS_NotPresent;
1586 break;
1587 }
1588
1589 satype.oe = (tsatype & 0x08) >> 3;
1590 switch(satype.oe) /*valid Values 0,1*/
1591 {
1592 // case OE_NotPresent:// =-1,
1593 case OE_Even :// = 0,
1594 case OE_Odd :// = 1
1595 break;
1596
1597 default:
1598 satype.oe = OE_NotPresent;
1599 break;
1600 }
1601
1602 return satype;
1603 }
1604
1605 /*
1606 +--------------------------------------------------------------------+
1607 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1608 | STATE : code ROUTINE : ci_remTrailCom |
1609 +--------------------------------------------------------------------+
1610
1611 PURPOSE : remove the trailing commas of an output line.
1612
1613 */
1614 GLOBAL void ci_remTrailCom (CHAR* outLine, USHORT len)
1615 {
1616 while (len)
1617 {
1618 if (outLine[--len] EQ ',')
1619 outLine[len] = '\0';
1620 else
1621 break;
1622 }
1623 }
1624
1625
1626 LOCAL void send_output_type_signal (T_ATI_SRC_PARAMS *src_params,
1627 UBYTE output_type)
1628 {
1629 if (src_params->line_state_cb NEQ NULL)
1630 {
1631 src_params->line_state_cb (src_params->src_id,
1632 ATI_LINE_STATE_OUTPUT_TYPE,
1633 (ULONG)output_type);
1634 }
1635 else
1636 {
1637 TRACE_EVENT_P1 ("[WRN] send_output_type_signal: no callback for srcId=%d",
1638 src_params->src_id);
1639 }
1640 }
1641
1642
1643 LOCAL void check_and_send_output_type_signal (T_ATI_SRC_PARAMS *src_params, CHAR *cmd)
1644 {
1645 int i = 0;
1646
1647 while (*large_output_cmd[i] NEQ '\0')
1648 {
1649 if (strcmp (large_output_cmd[i], cmd) EQ 0)
1650 {
1651 TRACE_EVENT("Command necessiting large output detected");
1652
1653 send_output_type_signal (src_params, ATI_OUTPUT_TYPE_LARGE);
1654 return;
1655 }
1656
1657 i++;
1658 }
1659
1660 send_output_type_signal (src_params, ATI_OUTPUT_TYPE_NORMAL);
1661 }
1662
1663
1664
1665 /*
1666 +--------------------------------------------------------------------+
1667 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1668 | STATE : code ROUTINE : aciAbort |
1669 +--------------------------------------------------------------------+
1670
1671 PURPOSE : abort currently executing command
1672
1673 */
1674
1675 GLOBAL void aciAbort (UBYTE srcId)
1676 {
1677 T_ACI_RETURN rslt;
1678 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
1679
1680 TRACE_FUNCTION ("aciAbort()");
1681
1682 if ( src_params->curAtCmd EQ AT_CMD_NONE OR
1683 src_params->curAtCmd EQ AT_CMD_ABRT )
1684 {
1685 return;
1686 }
1687
1688 if ( src_params->curAtCmd EQ AT_CMD_EXT )
1689 {
1690 g_sa[0] = ( CHAR ) ACI_EXT_STRG_END;
1691 if (ext_v2_flag EQ TRUE)
1692 {
1693 rslt = rEXT_Abort(srcId);
1694 }
1695 else
1696 {
1697 rslt = rAT_ACP ( g_sa, MAX_CMD_LEN - 1 );
1698 aci_sendPString ( srcId, g_sa );
1699 }
1700 switch ( rslt )
1701 {
1702 case ( AT_EXCT ):
1703 curAbrtCmd = AT_CMD_ABRT;
1704 break;
1705
1706 case ( AT_CMPL ):
1707 src_params->curAtCmd = AT_CMD_NONE;
1708 ledit_ctrl (srcId, LEDIT_CTRL_CMPL, NULL);
1709 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
1710 break;
1711
1712 default:
1713 {
1714 io_sendMessage ( srcId, cmdCmeError ( CME_ERR_FailedToAbort ),
1715 ATI_NORMAL_OUTPUT | ATI_RESULT_CODE_OUTPUT);
1716 }
1717 break;
1718 }
1719 }
1720 else
1721 {
1722 switch ( sAT_Abort (srcId, src_params->curAtCmd) )
1723 {
1724 case ( AT_EXCT ):
1725 curAbrtCmd = AT_CMD_ABRT;
1726 break;
1727
1728 case ( AT_CMPL ):
1729 src_params->curAtCmd = AT_CMD_NONE;
1730 ledit_ctrl (srcId, LEDIT_CTRL_CMPL, NULL);
1731 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
1732 cmdErrStr = NULL;
1733 break;
1734
1735 default:
1736 switch ( src_params->curAtCmd )
1737 {
1738 case ( AT_CMD_CMGC ):
1739 case ( AT_CMD_CNMI ):
1740 case ( AT_CMD_CSMS ):
1741 case ( AT_CMD_CMGD ):
1742 case ( AT_CMD_CMGR ):
1743 case ( AT_CMD_CMGW ):
1744 case ( AT_CMD_CMGS ):
1745 case ( AT_CMD_CMSS ):
1746 case ( AT_CMD_CPMS ):
1747 case ( AT_CMD_CSMP ):
1748 case ( AT_CMD_CSCA ):
1749 case ( AT_CMD_CRES ):
1750 case ( AT_CMD_CSAS ):
1751 case ( AT_CMD_CMGL ):
1752 io_sendMessage ( srcId, cmdCmsError ( CMS_ERR_FailedToAbort ),
1753 ATI_NORMAL_OUTPUT | ATI_RESULT_CODE_OUTPUT);
1754 break;
1755
1756 default:
1757 io_sendMessage ( srcId, cmdCmeError ( CME_ERR_FailedToAbort ),
1758 ATI_NORMAL_OUTPUT | ATI_RESULT_CODE_OUTPUT);
1759 }
1760 break;
1761 }
1762 }
1763 cmdErrStr = NULL;
1764 }
1765
1766 /*
1767 +--------------------------------------------------------------------+
1768 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
1769 | STATE : code ROUTINE :ati_execute_sat_cmd |
1770 +--------------------------------------------------------------------+
1771
1772 PURPOSE :
1773
1774 */
1775 #ifdef SIM_TOOLKIT
1776 GLOBAL BOOL ati_execute_sat_cmd (T_ATI_SRC_PARAMS *src_params,
1777 UBYTE *chars, USHORT len)
1778 {
1779 BOOL end_cmd_found = FALSE;
1780 UBYTE i;
1781 T_ACI_SAT_TERM_RESP resp_data;
1782
1783 psaSAT_InitTrmResp( &resp_data );
1784
1785 TRACE_FUNCTION ("ati_execute_sat_cmd ()");
1786
1787 for (i=0; i < len; i++)
1788 {
1789 if( chars[i] EQ '\r' ) /* for SAT hard coded S3=CR */
1790 {
1791 end_cmd_found = TRUE;
1792 break;
1793 }
1794 }
1795
1796 if( !end_cmd_found )
1797 {
1798 TRACE_EVENT("ERROR: run at command not terminated by at.S[3]");
1799 psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data );
1800 return(FALSE);
1801 }
1802
1803 ati_execute (src_params->src_id, chars, len);
1804 return(TRUE);
1805 }
1806 #endif /* SIM_TOOLKIT */
1807
1808
1809 /*
1810 +-------------------------------------------------------------------+
1811 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
1812 | ROUTINE : ati_execute_config_cmd |
1813 +-------------------------------------------------------------------+
1814
1815 PURPOSE :
1816 */
1817 GLOBAL BOOL ati_execute_config_cmd (UBYTE *chars, USHORT len)
1818 {
1819 BOOL S3_CR_found = FALSE;
1820 UBYTE i;
1821 T_ATI_SRC_PARAMS *src_params = NULL;
1822 static UBYTE cnf_src_id = 0;
1823 T_LEDIT_ATCMD *cmd = NULL;
1824
1825 TRACE_FUNCTION ("ati_execute_config_cmd()");
1826
1827 if (!cnf_src_id)
1828 {
1829 cnf_src_id = ati_init (ATI_SRC_TYPE_TST, NULL, NULL);
1830 if (!cnf_src_id)
1831 {
1832 TRACE_EVENT ("[ERR] ati_execute_config_cmd: cannot create source");
1833 return (FALSE);
1834 }
1835 TRACE_EVENT_P1 ("ati_execute_config_cmd: srcId=%d", cnf_src_id);
1836 }
1837 src_params = find_element (ati_src_list, cnf_src_id, search_ati_src_id);
1838
1839 if (src_params EQ NULL)
1840 {
1841 TRACE_EVENT_P1 ("[ERR] ati_execute_config_cmd: source ID=%d not found",
1842 cnf_src_id);
1843 return (FALSE);
1844 }
1845 if (src_params->cmd_state EQ CMD_RUNNING)
1846 {
1847 if ((ledit_get_current (src_params->src_id, &cmd) EQ LEDIT_CMPL) AND cmd)
1848 {
1849 TRACE_EVENT_P1 ("[WRN] ati_execute_config_cmd: command=%s is running", cmd->name);
1850 }
1851 else
1852 {
1853 TRACE_EVENT ("[ERR] ati_execute_config_cmd: command not available !"); /* then we have a real problem */
1854 }
1855 return (FALSE);
1856 }
1857
1858 for (i=0; i < len; i++)
1859 {
1860 if( chars[i] EQ '\r' ) /* */
1861 {
1862 S3_CR_found = TRUE;
1863 break;
1864 }
1865 }
1866
1867 if (S3_CR_found EQ FALSE)
1868 {
1869 /*
1870 * tell line edit that the line termination is not default '\r'
1871 */
1872 T_LEDIT line;
1873 line.S3 = 0x00; /* <== NULL terminated cmd line */
1874 line.S4 = at.S[4];
1875 line.S5 = at.S[5];
1876 line.smsEnd = 0x1a;
1877 line.atE = ati_user_output_cfg[src_params->src_id].atE;
1878 ledit_set_config (src_params->src_id, line);
1879 len = len+1;
1880 }
1881
1882 ati_execute (src_params->src_id, chars, len);
1883
1884 /* wait for command to be processed before allowing new command */
1885 return (FALSE);
1886 }
1887
1888 /*
1889 +-------------------------------------------------------------------+
1890 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
1891 | ROUTINE : ati_abort |
1892 +-------------------------------------------------------------------+
1893
1894 PURPOSE :
1895 */
1896 GLOBAL BOOL ati_abort (UBYTE src_id)
1897 {
1898 aciAbort (src_id);
1899
1900 return (TRUE);
1901 }
1902
1903 /*
1904 +-------------------------------------------------------------------+
1905 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
1906 | ROUTINE : ati_run_cmd_failed |
1907 +-------------------------------------------------------------------+
1908
1909 PURPOSE :
1910 */
1911 /*
1912 static void ati_run_cmd_failed (UBYTE src_id)
1913 {
1914 T_LEDIT_ERR *err = NULL;
1915 *
1916 * get the error reason
1917 *
1918 ledit_ctrl (src_id,LEDIT_CTRL_ERROR, &err);
1919 if (err AND err->msg)
1920 {
1921 io_sendMessageEx (src_id, err->msg, ATI_CONFIRM_OUTPUT);
1922 }
1923 else
1924 {
1925 io_sendMessageEx (src_id, "PANIC: NULL pointer !", ATI_CONFIRM_OUTPUT);
1926 }
1927 }
1928 */
1929
1930 /*
1931 +-------------------------------------------------------------------+
1932 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
1933 | ROUTINE : ati_run_ext_cmd |
1934 +-------------------------------------------------------------------+
1935
1936 PURPOSE : run a single extended AT command got from line edit
1937 */
1938 static T_ATI_RSLT ati_run_ext_cmd (T_ATI_SRC_PARAMS *src_params, T_LEDIT_ATCMD *cmd)
1939 {
1940 USHORT idx_fun = 0;
1941 TRACE_FUNCTION("ati_run_ext_cmd()");
1942 /*
1943 * doe we have it in cmds[] table ?
1944 */
1945 if ((idx_fun = find_index(cmd->name)) EQ 0)
1946 {
1947 if (ext_v2_flag EQ TRUE)
1948 {
1949 /*
1950 * AT cmd not listed in cmds[], return error
1951 */
1952 cmdCmeError(CME_ERR_OpNotAllow);
1953 return (ATI_FAIL);
1954 }
1955 else
1956 {
1957 /*
1958 * AT cmd not listed in cmds[], so try it with extension mechanism
1959 */
1960 return (aci_FwrdToEXT (src_params, cmd));
1961 }
1962 }
1963
1964 /*
1965 * remember the binary representation of the cmd
1966 */
1967 src_params->curAtCmd = cmds[idx_fun].binKey;
1968
1969 switch (cmd->type.sType)
1970 {
1971 case LEDIT_ATCMD_QUERY:
1972 {
1973 if (cmds[idx_fun].qfnc)
1974 {
1975 return (cmds[idx_fun].qfnc(cmd->params, src_params->src_id));
1976 }
1977 else
1978 {
1979 cmdCmeError(CME_ERR_OpNotAllow);
1980 return (ATI_FAIL); /* no function to query this cmd */
1981 }
1982 }
1983 case LEDIT_ATCMD_SET:
1984 {
1985 if (cmds[idx_fun].sfnc)
1986 {
1987 return (cmds[idx_fun].sfnc(cmd->params, src_params->src_id));
1988 }
1989 else
1990 {
1991 cmdCmeError(CME_ERR_OpNotAllow);
1992 return (ATI_FAIL); /* no function to set this cmd */
1993 }
1994 }
1995 case LEDIT_ATCMD_TEST:
1996 {
1997 if (cmds[idx_fun].tfnc)
1998 {
1999 return (cmds[idx_fun].tfnc(cmd->params, src_params->src_id));
2000 }
2001 else
2002 {
2003 cmdCmeError(CME_ERR_OpNotAllow);
2004 return (ATI_FAIL); /* no function to test this cmd */
2005 }
2006 }
2007 default:
2008 {
2009 cmdCmeError(CME_ERR_Unknown);
2010 return (ATI_FAIL);
2011 }
2012 }
2013 }
2014
2015 /*
2016 +-------------------------------------------------------------------+
2017 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2018 | ROUTINE : ati_run_cmd |
2019 +-------------------------------------------------------------------+
2020
2021 PURPOSE : run a single AT command got from line edit
2022 */
2023 static T_ATI_RSLT ati_run_cmd (T_ATI_SRC_PARAMS *src_params, T_LEDIT_ATCMD *cmd)
2024 {
2025 U16 idx_fun = 0;
2026
2027 cmdErrStr = NULL; /* reset error context */
2028
2029 trace_run_cmd_line ("ati_run_cmd", src_params->src_id, cmd->name, cmd->params);
2030
2031 check_and_send_output_type_signal (src_params, cmd->name);
2032
2033 if ((ext_v2_flag EQ TRUE) AND aci_SrchFwrdLst (src_params->src_id, cmd->name))
2034 {
2035 return (aci_FwrdToEXT (src_params, cmd));
2036 }
2037
2038 switch (cmd->type.mType)
2039 {
2040 /*********************/
2041 case LEDIT_ATCMD_DIAL:
2042 {
2043 return (atD (cmd->params, src_params->src_id));
2044 }
2045 /*********************/
2046 case LEDIT_ATCMD_AND:
2047 {
2048 if (cmds_bas[*(cmd->name) - 'A'].and_fnc NEQ NULL)
2049 {
2050 idx_fun = *(cmd->name) - 'A';
2051 return (cmds_bas[idx_fun].and_fnc(cmd->params, src_params->src_id));
2052 }
2053 else if (ext_v2_flag EQ FALSE)
2054 {
2055 /*
2056 * basic AT& cmd not listed in cmds_bas[], so try it with extension mechanism
2057 */
2058 return (aci_FwrdToEXT (src_params, cmd));
2059 }
2060 return AT_FAIL;
2061 }
2062 /*********************/
2063 case LEDIT_ATCMD_BASIC:
2064 {
2065 if (cmds_bas[*(cmd->name) - 'A'].fnc NEQ NULL)
2066 {
2067 /*
2068 * this is fix for atEFLMQVX, because there is a track backing to the cmd letter
2069 * e.g.: ATE0 -> we put E0 in tmp_buf, but pass &tmp_buf[1] !
2070 */
2071 CHAR tmp_buf[8];
2072 tmp_buf[0] = *(cmd->name);
2073 strcpy(&tmp_buf[1], cmd->params);
2074 idx_fun = *(cmd->name) - 'A';
2075 return (cmds_bas[idx_fun].fnc(&tmp_buf[1], src_params->src_id));
2076 }
2077 else if (ext_v2_flag EQ FALSE)
2078 {
2079 /*
2080 * basic AT cmd not listed in cmds_bas[], so try it with extension mechanism
2081 */
2082 return (aci_FwrdToEXT (src_params, cmd));
2083 }
2084 return AT_FAIL;
2085 }
2086 /*********************/
2087 case LEDIT_ATCMD_S:
2088 {
2089 /*
2090 * unfortunately we have to put the reg number, the cmd type and the params together in one buffer
2091 * else the ATCommand_bas cmds_bas[] does not work
2092 * e.g.: tmpBuf: 3=127 --> came from ATS3=127 --> user want to change termination character to 127
2093 */
2094 char tmpBuf[20];
2095 switch (cmd->type.sType)
2096 {
2097 case LEDIT_ATCMD_QUERY:
2098 {
2099 sprintf(tmpBuf,"%s?", cmd->name+1);
2100 return (atS (tmpBuf, src_params->src_id));
2101 }
2102 case LEDIT_ATCMD_TEST:
2103 {
2104 sprintf(tmpBuf,"%s=?", cmd->name+1);
2105 return (atS (tmpBuf, src_params->src_id));
2106 }
2107 case LEDIT_ATCMD_SET:
2108 {
2109 sprintf(tmpBuf,"%s=%s", cmd->name+1, cmd->params);
2110 return (atS (tmpBuf, src_params->src_id));
2111 }
2112 }
2113 break;
2114 }
2115 /*********************/
2116 case LEDIT_ATCMD_EXTENDED:
2117 {
2118 /*
2119 * do we have to push to extension mechanism ?
2120 */
2121 if (!aci_cmhActive (src_params->src_id) AND aci_SrchFwrdLst (src_params->src_id, cmd->name))
2122 {
2123 if (src_params EQ NULL)
2124 {
2125 TRACE_EVENT ("[ERR] ati_execute: source ID not found");
2126 return (ATI_FAIL);
2127 }
2128 return (aci_FwrdToEXT (src_params, cmd));
2129 }
2130 return (ati_run_ext_cmd (src_params, cmd));
2131 }
2132 } /* end of switch (cmd->type.mType) */
2133
2134 /* default: */
2135 {
2136 cmdCmeError(CME_ERR_OpNotAllow);
2137 return (ATI_FAIL);
2138 }
2139 }
2140
2141 /*
2142 +-------------------------------------------------------------------+
2143 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2144 | ROUTINE : ati_run_cmd_line_next |
2145 +-------------------------------------------------------------------+
2146
2147 PURPOSE : - after line edit processed a raw AT command line to
2148 canonical form, call here the appropriate functions
2149 for each single AT command
2150 */
2151 LOCAL T_ATI_RSLT ati_run_cmd_line_next (T_ATI_SRC_PARAMS *src_params)
2152 {
2153 T_ATI_RSLT rv_ati = ATI_FAIL;
2154 T_LEDIT_ATCMD *cmd = NULL;
2155
2156 if (src_params->text_mode EQ TXT_MODE)
2157 {
2158 /*
2159 * here we are when changed from cmd to text mode
2160 *
2161 * we use the current cmd (e.g.: +CMGS) where the parameter was the destination adress
2162 * but now we put the text as parameter
2163 * example: AT+CMGS="1234567890";+CPBR=1,100
2164 * |__change to text mode (user interactively edit the text)
2165 * "Hello this is SMS text<Ctrl-Z>"
2166 * +CMGS="Hello this is SMS text<Ctrl-Z>" <-- call now CMGS a second time, but with text
2167 */
2168 if ((ledit_get_current (src_params->src_id, &cmd) EQ LEDIT_CMPL) AND cmd)
2169 {
2170 if (ledit_get_text (src_params->src_id, &cmd->params) EQ LEDIT_FAIL)
2171 {
2172 cmdCmeError(CME_ERR_Unknown); /* hmm, internal failure */
2173 }
2174
2175 return (ati_run_cmd (src_params, cmd)); /* process the text */
2176 }
2177 else
2178 {
2179 cmdCmeError(CME_ERR_Unknown); /* hmm, internal failure */
2180 return (ATI_FAIL);
2181 }
2182 }
2183 else /* CMD_MODE */
2184 {
2185 cmd = NULL;
2186 rv_ati = ATI_CMPL; /* when there is no further cmd */
2187 /*
2188 * and possibly next commands follows
2189 * (when the last cmd sent a primitive to another entity,
2190 * then ati_run_cmd_line was called by rCI_OK (asynchroniously),
2191 * instead of ati_execute (the synchronized case))
2192 */
2193
2194 while (ledit_ctrl(src_params->src_id,LEDIT_CTRL_MORE_CMDS, NULL) EQ LEDIT_CMPL)
2195 {
2196 if (ledit_get_next (src_params->src_id, &cmd) EQ LEDIT_FAIL)
2197 return ATI_FAIL;
2198 if (cmd EQ NULL)
2199 return ATI_FAIL;
2200 if ((rv_ati = ati_run_cmd (src_params, cmd)) NEQ ATI_CMPL)
2201 {
2202 break;
2203 }
2204 cmd = NULL;
2205 }
2206 return rv_ati;
2207 }
2208 }
2209
2210 /*
2211 +-------------------------------------------------------------------+
2212 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2213 | ROUTINE : ati_run_cmd_line |
2214 +-------------------------------------------------------------------+
2215
2216 PURPOSE : - after line edit processed a raw AT command line to
2217 canonical form, call here the appropriate functions
2218 for each single AT command
2219 */
2220 LOCAL T_ATI_RSLT ati_run_cmd_line (T_ATI_SRC_PARAMS *src_params)
2221 {
2222 T_ATI_RSLT rv_ati = ATI_FAIL;
2223
2224 T_LEDIT_ATCMD *cmd = NULL;
2225 TRACE_FUNCTION("ati_run_cmd_line()");
2226
2227 if (src_params->cmd_state EQ CMD_TYPING) /* a new command line */
2228 {
2229 trace_cmd_state(src_params->src_id, src_params->cmd_state, CMD_RUNNING);
2230 src_params->cmd_state = CMD_RUNNING;
2231 /*
2232 * start with the first command
2233 */
2234 if ((ledit_get_first (src_params->src_id, &cmd) EQ LEDIT_CMPL) AND cmd)
2235 {
2236 rv_ati = ati_run_cmd (src_params, cmd);
2237 }
2238 else
2239 {
2240 TRACE_EVENT("failed to run first AT command !");
2241 cmdCmeError(CME_ERR_Unknown); /* hmm, internal failure */
2242 }
2243 if (rv_ati EQ ATI_CMPL)
2244 {
2245 rv_ati = ati_run_cmd_line_next (src_params); /* for possible next synchronious cmds */
2246 }
2247 }
2248 else
2249 {
2250 rv_ati = ati_run_cmd_line_next (src_params); /* for asynchronious cmds */
2251 }
2252 /*
2253 * evaluate the return value of the AT cmd
2254 */
2255 if (rv_ati NEQ ATI_EXCT)
2256 {
2257 /*
2258 * tell line edit that the cmd line is finished
2259 * and to be able to receive a new one
2260 */
2261 ledit_ctrl (src_params->src_id,LEDIT_CTRL_CMPL, NULL);
2262
2263 trace_cmd_state(src_params->src_id, src_params->cmd_state, CMD_IDLE);
2264 src_params->cmd_state = CMD_IDLE;
2265 src_params->text_mode = CMD_MODE;
2266 }
2267
2268 switch (rv_ati)
2269 {
2270 case (ATI_CMPL_NO_OUTPUT):
2271 TRACE_EVENT("AT command line processed, but look for rCI_OK for success") ;
2272 break;
2273
2274 case (ATI_CMPL):
2275 /*
2276 * if extension command reset the global src_id_ext
2277 */
2278 if (src_id_ext EQ src_params->src_id)
2279 {
2280 src_id_ext = 0xFF;
2281 }
2282
2283 TRACE_EVENT("AT command line successfully processed") ;
2284 io_sendConfirm (src_params->src_id, cmdAtError(atOk), ATI_NORMAL_OUTPUT);
2285 break;
2286
2287 case (ATI_FAIL):
2288 /*
2289 * if extension command reset the global src_id_ext
2290 */
2291 if (src_id_ext EQ src_params->src_id)
2292 {
2293 src_id_ext = 0xFF;
2294 }
2295
2296 if (cmdErrStr EQ NULL)
2297 {
2298 /* set cmdErrStr to default error */
2299 cmdAtError(atError);
2300 }
2301
2302 io_sendConfirm (src_params->src_id, cmdErrStr, ATI_ERROR_OUTPUT);
2303 cmdErrStr = NULL;
2304 break;
2305
2306 case (ATI_FAIL_NO_OUTPUT):
2307 break;
2308
2309 case (ATI_BUSY):
2310 TRACE_EVENT("BUSY !") ;
2311 cmdCmeError(CME_ERR_Unknown);
2312 io_sendConfirm (src_params->src_id, cmdErrStr, ATI_ERROR_OUTPUT);
2313 cmdErrStr = NULL;
2314 break;
2315
2316 case (ATI_EXCT):
2317 break;
2318
2319 } /* end of switch (rv_ati) */
2320
2321 return (rv_ati);
2322 }
2323
2324
2325 /*
2326 +-------------------------------------------------------------------+
2327 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2328 | ROUTINE : ati_execute_cmd_line |
2329 +-------------------------------------------------------------------+
2330
2331 PURPOSE : called by ati_execute_eval_rslt when LEDIT_CMPL
2332 or LEDIT_ESC (but after <ESC> a SMS there are further cmds).
2333 rCI_OK calls asynchroniously this function, as well
2334 */
2335 /*
2336 * first_prompt is used by ati_execute_cmd_line() and ati_execute_eval_rslt() only
2337 */
2338 static BOOL first_prompt = FALSE;
2339
2340 GLOBAL T_ATI_RSLT ati_execute_cmd_line (T_ATI_SRC_PARAMS *src_params)
2341 {
2342 /*
2343 * process the command line
2344 */
2345 T_ATI_RSLT rv_ati = ati_run_cmd_line (src_params);
2346
2347 if ((rv_ati EQ ATI_EXCT) AND (src_params->text_mode EQ TXT_MODE))
2348 {
2349 if(first_prompt EQ FALSE)
2350 {
2351 /*
2352 * emit the very first prompt "> " when switched from cmd to text mode
2353 */
2354 ledit_ctrl (src_params->src_id,LEDIT_CTRL_PROMPT, NULL);
2355 io_sendMessageEx (src_params->src_id, g_ledit_echoBuf, ATI_CONFIRM_OUTPUT);
2356 first_prompt = TRUE;
2357 }
2358 }
2359 else
2360 {
2361 first_prompt = FALSE; /* reset in CMD_MODE */
2362 }
2363 return (rv_ati);
2364 }
2365
2366 /*
2367 +-------------------------------------------------------------------+
2368 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2369 | ROUTINE : ati_execute_eval_rslt |
2370 +-------------------------------------------------------------------+
2371
2372 PURPOSE : evaluate the result value of line edit and execute the AT cmd line
2373 */
2374 LOCAL T_ATI_RSLT ati_execute_eval_rslt (UBYTE src_id, T_ATI_SRC_PARAMS *src_params, T_LEDIT_RSLT rv_ledit)
2375 {
2376 TRACE_FUNCTION ("ati_execute_eval_rslt()");
2377
2378 if ((rv_ledit EQ LEDIT_FAIL)
2379 OR (rv_ledit EQ LEDIT_OK)) /* for <CR> and [aAtT]<CR> they want to see an OK */
2380 {
2381 ledit_ctrl (src_id,LEDIT_CTRL_CMPL, NULL);
2382 trace_cmd_state(src_params->src_id, src_params->cmd_state, CMD_IDLE);
2383 src_params->cmd_state = CMD_IDLE;
2384 src_params->text_mode = CMD_MODE;
2385 }
2386
2387 switch (rv_ledit)
2388 {
2389 case (LEDIT_CMPL): /* line edit has a valid AT command line or text line */
2390 {
2391 char trcBuf[80];
2392 TRACE_EVENT ("ati_execute_eval_rslt(): rv_ledit = LEDIT_CMPL");
2393 /*
2394 * emit a trace of the entire cmd line
2395 * we have to put the prefix AT here, because ledit
2396 * keeps a canonical cmd line, where prefix and white spaces are stripped off
2397 */
2398 trcBuf[0]='A';
2399 trcBuf[1]='T';
2400 if ((ledit_trace_line (src_id, &trcBuf[2])) EQ LEDIT_CMPL)
2401 {
2402 trace_cmd_line ("IN:", trcBuf,
2403 src_id,
2404 (USHORT)strlen(trcBuf));
2405 }
2406
2407 return (ati_execute_cmd_line (src_params));
2408 }
2409 case (LEDIT_FAIL): /* non valid command line */
2410 {
2411 TRACE_EVENT ("ati_execute_eval_rslt(): rv_ledit = LEDIT_FAIL");
2412 io_sendConfirm (src_params->src_id, cmdAtError(atError), ATI_ERROR_OUTPUT);
2413 cmdErrStr = NULL;
2414 return (ATI_FAIL);
2415 }
2416 case (LEDIT_ESC): /* if in text mode <ESC> was sent, then no error message, but an OK */
2417 {
2418 TRACE_EVENT("ati_execute_eval_rslt(): Send message command cancelled by user and catched by line edit");
2419 src_params->text_mode = CMD_MODE;
2420 first_prompt = FALSE;
2421
2422 if (ledit_ctrl(src_params->src_id,LEDIT_CTRL_MORE_CMDS, NULL) EQ LEDIT_CMPL)
2423 {
2424 /* <Esc> was sent, but there are further cmds */
2425 return (ati_execute_cmd_line (src_params));
2426 }
2427 else
2428 {
2429 ledit_ctrl (src_id,LEDIT_CTRL_CMPL, NULL);
2430 trace_cmd_state(src_params->src_id, src_params->cmd_state, CMD_IDLE);
2431 src_params->cmd_state = CMD_IDLE;
2432 io_sendConfirm (src_params->src_id, cmdAtError(atOk), ATI_NORMAL_OUTPUT);
2433 return (ATI_CMPL);
2434 }
2435 }
2436 case (LEDIT_COLLECT): /* line edit is (still) in COLLECT mode (both cmd/text mode) */
2437 {
2438 TRACE_EVENT ("ati_execute_eval_rslt(): rv_ledit = LEDIT_COLLECT");
2439 return (ATI_EXCT);
2440 }
2441 case (LEDIT_OK): /* line edit recognized a single <CR> or simple "AT<CR>", so emit an OK */
2442 {
2443 TRACE_EVENT ("ati_execute_eval_rslt(): rv_ledit = LEDIT_OK");
2444 io_sendConfirm (src_params->src_id, cmdAtError(atOk), ATI_NORMAL_OUTPUT);
2445 return (ATI_CMPL);
2446 }
2447 case (LEDIT_IGNORE): /* malberto will be interpreted as ato ;-) */
2448 {
2449 TRACE_EVENT ("ati_execute_eval_rslt(): rv_ledit = LEDIT_IGNORE");
2450 return (ATI_EXCT);
2451 }
2452 default:
2453 {
2454 TRACE_ERROR("ati_execute(): invalid state");
2455 return (ATI_FAIL);
2456 }
2457 } /* end of switch (rv_ledit) */
2458 }
2459
2460 /*
2461 +-------------------------------------------------------------------+
2462 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2463 | ROUTINE : ati_execute |
2464 +-------------------------------------------------------------------+
2465
2466 PURPOSE :
2467 */
2468 GLOBAL T_ATI_RSLT ati_execute (UBYTE src_id, UBYTE *chars, USHORT len)
2469 {
2470 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, src_id, search_ati_src_id);
2471
2472 T_LEDIT_ATCMD *cmd = NULL;
2473 T_LEDIT_ERR *err = NULL;
2474 T_LEDIT_RSLT rv_ledit = LEDIT_FAIL;
2475
2476 TRACE_FUNCTION ("ati_execute()");
2477
2478 if (src_params EQ NULL)
2479 {
2480 TRACE_EVENT ("[ERR] ati_execute: source ID not found");
2481 return (ATI_FAIL);
2482 }
2483
2484 /* Global variable srcId_cb is set with current source Id */
2485 srcId_cb = src_id;
2486
2487 /*
2488 * the source sent a char, chunk of chars or a complete AT command line,
2489 * so ATI is for this source in state CMD_TYPING
2490 */
2491 if (src_params->cmd_state EQ CMD_RUNNING)
2492 {
2493 ; /* keep CMD_RUNNING state for the second call of SMS-edit functions CMGW and CMGS in TEXT-Mode */
2494 }
2495 else /* trigger starting of new cmdline */
2496 {
2497 trace_cmd_state(src_params->src_id, src_params->cmd_state, CMD_TYPING);
2498 src_params->cmd_state = CMD_TYPING;
2499 }
2500
2501 /*
2502 * call line edit to pre process the command line
2503 */
2504 if (src_params->text_mode EQ CMD_MODE)
2505 {
2506 rv_ledit = ledit_cmd (src_id, chars, len);
2507 }
2508 else
2509 {
2510 rv_ledit = ledit_text (src_id, chars, len);
2511 }
2512 /*
2513 * echo the received characters when source has been set to echo,
2514 * but not for e.g.: the "mAlberTO" phenomenon --> ATO, where "m lber" are ignored
2515 */
2516 if ((ati_user_output_cfg[src_params->src_id].atE) AND (rv_ledit NEQ LEDIT_IGNORE))
2517 {
2518 /* if only '\b' is printed clean the current character */
2519 if ((g_ledit_echoBuf[0] EQ at.S[5]) AND (g_ledit_echoBuf[1] EQ '\0'))
2520 {
2521 char delseq[4];
2522 delseq[0]=at.S[5];
2523 delseq[1]=' ';
2524 delseq[2]=at.S[5];
2525 delseq[3]='\0';
2526 /* This will wipe current character from terminal */
2527 io_sendMessageEx (src_params->src_id, delseq, ATI_ECHO_OUTPUT);
2528 }
2529 else
2530 {
2531 io_sendMessageEx (src_params->src_id, g_ledit_echoBuf, ATI_ECHO_OUTPUT);
2532 }
2533 }
2534 /*
2535 * evaluate the result value of line edit and execute the cmd line
2536 */
2537 return (ati_execute_eval_rslt (src_id, src_params, rv_ledit));
2538 }
2539
2540
2541 /*
2542 +-------------------------------------------------------------------+
2543 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2544 | ROUTINE : init_ati |
2545 +-------------------------------------------------------------------+
2546
2547 PURPOSE :
2548 */
2549 GLOBAL void init_ati (void)
2550 {
2551 ati_src_list = new_list ();
2552 rEXT_Init();
2553 }
2554
2555 /*
2556 +-------------------------------------------------------------------+
2557 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2558 | ROUTINE : ati_init |
2559 +-------------------------------------------------------------------+
2560
2561 PURPOSE :
2562 */
2563 GLOBAL UBYTE ati_init (T_ATI_SRC_TYPE src_type,
2564 T_ATI_RESULT_CB *result_cb,
2565 T_ATI_LINE_STATE_CB *line_state_cb)
2566 {
2567 UBYTE src_id;
2568 T_ATI_SRC_PARAMS *src_params;
2569
2570 TRACE_FUNCTION ("ati_init ()");
2571
2572 src_id = aci_init (src_type);
2573 if (src_id EQ 0)
2574 {
2575 return (0);
2576 }
2577
2578 aci_cmd_src_mode_set(src_id,CMD_MODE_ATI);
2579
2580 #ifdef FF_ATI_BAT
2581 /* we use test or uart source as application and user of the BAT library */
2582 if ((src_type EQ ATI_SRC_TYPE_TST)
2583 OR (src_type EQ ATI_SRC_TYPE_UART))
2584 {
2585 if (ati_bat_globs.bat_lib_initialized EQ FALSE)
2586 {
2587 ati_bat_lib_init(src_id);
2588 }
2589 ati_bat_lib_new(src_id, src_type); /* one instance per ATI source */
2590 ati_bat_open_client(src_id); /* but only one client per instance */
2591 }
2592 #endif /* FF_ATI_BAT */
2593
2594 ACI_MALLOC (src_params, sizeof (T_ATI_SRC_PARAMS));
2595
2596 src_params->src_id = src_id;
2597 src_params->src_type = src_type;
2598 src_params->result_cb = result_cb;
2599 src_params->line_state_cb = line_state_cb;
2600 src_params->cmd_state = CMD_IDLE;
2601 src_params->buff_uns_mode = BUFF_RUNNING;
2602 src_params->indication_buffer = NULL;
2603 src_params->text_mode = CMD_MODE;
2604 src_params->curAtCmd = AT_CMD_NONE;
2605 src_params->mode = ATI_UNKN_MODE;
2606
2607 insert_list (ati_src_list, src_params);
2608
2609 return (src_id);
2610 }
2611
2612 /*
2613 +-------------------------------------------------------------------+
2614 | PROJECT : GSM-PS (6147) MODULE : ati_cmd |
2615 | ROUTINE : ati_finit |
2616 +-------------------------------------------------------------------+
2617
2618 PURPOSE :
2619 */
2620 GLOBAL void ati_finit (UBYTE src_id)
2621 {
2622 T_ATI_SRC_PARAMS *src_params;
2623
2624 TRACE_EVENT_P1("ati_finit(): source: %d", src_id);
2625
2626 src_params = remove_element (ati_src_list, src_id, search_ati_src_id);
2627 if (src_params EQ NULL)
2628 {
2629 /* often seen with pei_exit() during simulation, because tries to close all sources,
2630 but there are not so many open */
2631 TRACE_EVENT_P1 ("ati_finit(): source: %d not found", src_id);
2632 return;
2633 }
2634
2635 ACI_MFREE (src_params);
2636
2637 aci_finit (src_id);
2638
2639 #ifdef FF_ATI_BAT
2640 ati_bat_close_client(src_id);
2641 if (ati_bat_all_clients_closed())
2642 {
2643 ati_bat_lib_finit();
2644 }
2645 #endif
2646 }
2647
2648
2649 /*
2650 +--------------------------------------------------------------------+
2651 | PROJECT: GSM-PS (6147) MODULE: ACI_CMD |
2652 | STATE : code ROUTINE: aci_timeout |
2653 +--------------------------------------------------------------------+
2654
2655 PURPOSE : A timeout has occured for a timer. The function returns
2656 TRUE, if it is a timer which is handled by ACI, else FALSE
2657 is returned to indicate that the timer has not been
2658 processed.
2659
2660 */
2661 UBYTE aci_timeout (USHORT index)
2662 {
2663 TRACE_FUNCTION ("aci_timeout()");
2664
2665 if (index EQ ACI_TRING)
2666 {
2667 /*
2668 * timeout ring timer
2669 */
2670 aciRingTimeout ();
2671 return TRUE;
2672 }
2673 if (index EQ ACI_CNMA_TIMER_HANDLE)
2674 {
2675 /*
2676 * timeout +CNMA waiting timer
2677 */
2678 aciCnmaTimeout();
2679 return TRUE;
2680 }
2681
2682 /*
2683 * the timeout is not for ACI
2684 */
2685 return FALSE;
2686 }
2687
2688 /*
2689 +--------------------------------------------------------------------+
2690 | PROJECT: GSM-PS (6147) MODULE: ACI_CMD |
2691 | STATE : code ROUTINE: aciRingTimeout |
2692 +--------------------------------------------------------------------+
2693
2694 PURPOSE : +CNMA timeout. Relay function for cmd_handleCnmaTimeout();
2695 */
2696 void aciCnmaTimeout( void )
2697 {
2698 cmd_handleCnmaTimeout();
2699 }
2700
2701
2702 /*
2703 +--------------------------------------------------------------------+
2704 | PROJECT: GSM-PS (6147) MODULE: ACI_CMD |
2705 | STATE : code ROUTINE: aciRingTimeout |
2706 +--------------------------------------------------------------------+
2707
2708 PURPOSE : Ring timeout. Check S0 register for automatic answer mode.
2709 Indicate ring and accept call if S0 value is reached
2710 */
2711 void aciRingTimeout ( void )
2712 {
2713 UBYTE idx;
2714
2715 TRACE_FUNCTION ("aciRingTimeout()");
2716
2717 /* indicate ringing */
2718 at.rngPrms.rngCnt++;
2719
2720 for (idx = 0; idx < CMD_SRC_MAX; idx++)
2721 {
2722 if ((idx NEQ CMD_SRC_LCL) AND IS_SRC_USED (idx))
2723 {
2724 srcId_cb = idx;
2725 if (!at.rngPrms.isRng) /* only handle the subsequent sources if ringing was not stopped */
2726 break;
2727 rCI_PlusCRING ( at.rngPrms.mode, at.rngPrms.type1, at.rngPrms.type2 );
2728
2729 #ifdef NO_ASCIIZ
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, (at.clipPrms.alpha.len)?(&at.clipPrms.alpha):NULL );
2733 #else
2734 rCI_PlusCLIP ( at.clipPrms.stat, strlen(at.clipPrms.number)?(at.clipPrms.number):NULL, &at.clipPrms.type,
2735 at.clipPrms.validity, strlen(at.clipPrms.subaddr)?(at.clipPrms.subaddr):NULL,
2736 &at.clipPrms.satype, strlen(at.clipPrms.alpha)?(at.clipPrms.alpha):NULL );
2737 #endif
2738 }
2739 }
2740 }
2741
2742 /*
2743 +--------------------------------------------------------------------+
2744 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2745 | STATE : code ROUTINE : find_index |
2746 +--------------------------------------------------------------------+
2747
2748 PURPOSE : find index_function
2749
2750 */
2751 static SHORT find_index(CHAR * cl)
2752 {
2753 int i = 1;
2754
2755 while (cmds[i].key NEQ NULL)
2756 {
2757 if (strcmp (cl, cmds[i].key) EQ 0) /* command found */
2758 return (i);
2759
2760 i++;
2761 }
2762
2763 return (0);
2764 }
2765
2766 /*
2767 +-------------------------------------------------------------------+
2768 | PROJECT : GSM-PS (6147) MODULE : ATI |
2769 | STATE : code ROUTINE : ati_get_cmds_key |
2770 +-------------------------------------------------------------------+
2771
2772 PURPOSE : This function returns the cmd key "+CMD" from the command id
2773 */
2774
2775 GLOBAL void ati_get_cmds_key (T_ACI_AT_CMD cmd_id, CHAR **cmd_key, CHAR **testcmd_output)
2776 {
2777 int i = 1;
2778
2779 while (cmds[i].key NEQ NULL)
2780 {
2781 if (cmds[i].binKey EQ cmd_id) /* command found */
2782 {
2783 break;
2784 }
2785 i++;
2786 }
2787
2788 if (cmds[i].key EQ NULL)
2789 {
2790 TRACE_EVENT_P1("Command not found !!! cmd_id: %d", cmd_id);
2791 return;
2792 }
2793
2794 if (cmd_key NEQ NULL)
2795 {
2796 *cmd_key = cmds[i].key;
2797 }
2798
2799 if (testcmd_output NEQ NULL)
2800 {
2801 *testcmd_output = cmds[i].output1;
2802 }
2803 }
2804
2805 /*
2806 +--------------------------------------------------------------------+
2807 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2808 | STATE : code ROUTINE : resp_disp |
2809 +--------------------------------------------------------------------+
2810
2811 PURPOSE : display response
2812 */
2813
2814 GLOBAL CHAR *resp_disp (UBYTE srcId, CHAR *cl,CHAR *type, ...)
2815 /*types: "llsle..." b:BYTE l:LONG s:SHORT
2816 e:enum or int x: enum in X */
2817 {
2818 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
2819 va_list varpars; /* varpars not to be initialised as it is not scalar */
2820 USHORT i = 0;
2821 SHORT pos,
2822 buf_length,
2823 type_length = 0;
2824 CHAR *cmd_key = "";
2825
2826 if (type NEQ NULL)
2827 {
2828 type_length = strlen(type);
2829 }
2830
2831 va_start (varpars, type);
2832
2833 ati_get_cmds_key (src_params->curAtCmd, &cmd_key, NULL);
2834
2835 pos = sprintf (g_sa,"%s: ", cmd_key);
2836
2837 while ( i < type_length)
2838 {
2839 switch(*type)
2840 {
2841 case('b'):
2842 pos += sprintf(g_sa+pos,"%d,",*(va_arg (varpars,BYTE*)));
2843 break;
2844 case('e'):
2845 pos += sprintf(g_sa+pos,"%d,",*(va_arg (varpars,int*)));
2846 break;
2847 case('l'):
2848 pos += sprintf(g_sa+pos,"%d,",*(va_arg (varpars,LONG*)));
2849 break;
2850 case('s'):
2851 pos += sprintf(g_sa+pos,"%d,",*(va_arg (varpars,SHORT*)));
2852 break;
2853 case('x'):
2854 pos += sprintf(g_sa+pos,"%X,",*(va_arg (varpars,int*)));
2855 }
2856 i++;
2857 type++;
2858 }
2859 buf_length = strlen(g_sa);
2860 g_sa[buf_length - 1] = '\0'; /* to get rid of the last comma */
2861
2862 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
2863 va_end (varpars); /* Reset variable arguments. */
2864 return cl;
2865 }
2866
2867 /*
2868 +--------------------------------------------------------------------+
2869 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2870 | STATE : code ROUTINE : test_gen |
2871 +--------------------------------------------------------------------+
2872
2873 PURPOSE : generic test function
2874 */
2875
2876 static T_ATI_RSLT test_gen(CHAR * cl, UBYTE srcId)
2877 {
2878 CHAR *cmd_key = "";
2879 CHAR *testcmd_output = "";
2880 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
2881
2882 TRACE_FUNCTION("test_gen()");
2883
2884 ati_get_cmds_key (src_params->curAtCmd, &cmd_key, &testcmd_output);
2885
2886 if (testcmd_output NEQ NULL)
2887 {
2888 sprintf (g_sa, testcmd_output, cmd_key);
2889 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT);
2890 }
2891 return (ATI_CMPL);
2892 }
2893
2894 /*
2895 +--------------------------------------------------------------------+
2896 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2897 | STATE : code ROUTINE : atPlusCLAC |
2898 +--------------------------------------------------------------------+
2899
2900 PURPOSE : +CLAC command (List AT commands list)
2901 */
2902
2903 GLOBAL T_ATI_RSLT atPlusCLAC (char *cl, UBYTE srcId)
2904 {
2905 int i = 1 /*0*/; /* because of new cmds[] table */
2906 int j = 0;
2907
2908 TRACE_FUNCTION("atPlusCLAC()");
2909
2910 if ( *cl EQ '\0' OR *cl EQ ';' )
2911 {
2912 if ( *cl EQ ';' )
2913 cl++;
2914
2915 while (cmds[i].key NEQ NULL)
2916 {
2917 sprintf(g_sa,"AT%s",cmds[i].key);
2918 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
2919 i++;
2920 }
2921 for (;j<26;j++)
2922 {
2923 if (cmds_bas[j].key) /* Output if present */
2924 {
2925 sprintf(g_sa,"AT%s",cmds_bas[j].key);
2926 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
2927 }
2928 if (cmds_bas[j].and_key) /* Output if present */
2929 {
2930 sprintf(g_sa,"AT%s",cmds_bas[j].and_key);
2931 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
2932 }
2933 }
2934 }
2935 else
2936 {
2937 cmdCmeError (CME_ERR_OpNotSupp);
2938 return (ATI_FAIL);
2939 }
2940
2941 return (ATI_CMPL);
2942 }
2943
2944
2945
2946 /*
2947 +--------------------------------------------------------------------+
2948 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
2949 | STATE : code ROUTINE : atPlusGCI |
2950 +--------------------------------------------------------------------+
2951
2952 PURPOSE : +GCI command (manufacturer identification)
2953 */
2954
2955 GLOBAL T_ATI_RSLT setatPlusGCI(char *cl, UBYTE srcId)
2956 {
2957 T_ACI_RETURN ret;
2958 UBYTE country; /* check if long enough */
2959 SHORT pos=0;
2960
2961 TRACE_FUNCTION("setatPlusGCI()");
2962
2963 switch (*cl)
2964 {
2965 case('='):
2966 {
2967 cl++;
2968 cl=parse(cl,"h",&country);
2969 if(!cl)/*OR country > 0xff) this expression always returns false (LINT)*/
2970 {
2971 cmdAtError(atError);
2972 return (ATI_FAIL);
2973 }
2974 ret = sAT_PlusGCI(srcId ,country);
2975 break;
2976 }
2977 default:
2978 {
2979 cmdAtError(atError);
2980 return (ATI_FAIL);
2981 }
2982 }
2983 if (ret EQ AT_FAIL)
2984 {
2985 cmdAtError(atError);
2986 return (ATI_FAIL);
2987 }
2988 return (ATI_CMPL);
2989 }
2990
2991 GLOBAL T_ATI_RSLT queatPlusGCI(char *cl, UBYTE srcId)
2992 {
2993 T_ACI_RETURN ret;
2994 UBYTE country; /* check if long enough */
2995 SHORT pos=0;
2996
2997 TRACE_FUNCTION("atPlusGCI()");
2998
2999 ret=qAT_PlusGCI(srcId,&country);
3000 if (ret EQ AT_CMPL)
3001 {
3002 pos=sprintf(g_sa,"+GCI:%02X",country);
3003 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
3004 return (ATI_CMPL);
3005 }
3006 else
3007 {
3008 cmdAtError(atError);
3009 return (ATI_FAIL);
3010 }
3011 }
3012
3013 /*
3014 +--------------------------------------------------------------------+
3015 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3016 | STATE : code ROUTINE : atPlusCCWE |
3017 +--------------------------------------------------------------------+
3018
3019 PURPOSE : +CCWE Call Meter Maximum Event
3020 */
3021
3022 GLOBAL T_ATI_RSLT setatPlusCCWE(char *cl, UBYTE srcId)
3023 {
3024 SHORT mode = ACI_NumParmNotPresent;
3025
3026 TRACE_FUNCTION ( "setatPlusCCWE()" );
3027
3028 cl = parse ( cl, "d", &mode );
3029 if ( !cl OR mode > 1 OR mode < 0 )
3030 {
3031 cmdCmeError ( CME_ERR_OpNotAllow );
3032 return (ATI_FAIL);
3033 }
3034
3035 ati_user_output_cfg[srcId].CCWE_stat = ( UBYTE ) mode;
3036 return (ATI_CMPL);
3037 }
3038
3039
3040 GLOBAL T_ATI_RSLT queatPlusCCWE(char *cl, UBYTE srcId)
3041 {
3042 TRACE_FUNCTION ( "queatPlusCCWE()" );
3043
3044 resp_disp(srcId, cl,"b",&ati_user_output_cfg[srcId].CCWE_stat);
3045 return (ATI_CMPL);
3046 }
3047
3048 /*
3049 +--------------------------------------------------------------------+
3050 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3051 | STATE : code ROUTINE : aci_sendPString |
3052 +--------------------------------------------------------------------+
3053
3054 PURPOSE : This function is used to send a PASCAL like string to
3055 the serial interface.
3056 */
3057 GLOBAL void aci_sendPString (UBYTE srcId, CHAR* buffer)
3058 {
3059 UBYTE nextLen;
3060 UBYTE actLen;
3061
3062 TRACE_FUNCTION ( "aci_sendPString ()" );
3063
3064 nextLen = buffer[0];
3065
3066 while ( nextLen NEQ ACI_EXT_STRG_END)
3067 {
3068 actLen = nextLen;
3069 nextLen = buffer[actLen + 1];
3070 buffer[actLen + 1] = '\0';
3071
3072 io_sendMessage ( srcId, &buffer[1], ATI_NORMAL_OUTPUT );
3073
3074 buffer[actLen + 1] = (CHAR)nextLen;
3075
3076 buffer = &buffer[actLen + 1];
3077 }
3078 }
3079
3080 /*
3081 +--------------------------------------------------------------------+
3082 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3083 | STATE : code ROUTINE : sAT_CfgEXT |
3084 +--------------------------------------------------------------------+
3085
3086 PURPOSE : This function is used to store the list of AT command
3087 which are forwarded to the AT command extension module
3088 in case mobile is not registered (neither limited nor
3089 full service is available).
3090 */
3091 GLOBAL T_ACI_RETURN sAT_CfgEXT ( CHAR** fwrdLst )
3092 {
3093 TRACE_FUNCTION ( "sAT_CfgEXT ()" );
3094
3095 atCmdFwrdLst = fwrdLst;
3096
3097 return ( AT_CMPL );
3098 }
3099
3100 /*
3101 +--------------------------------------------------------------------+
3102 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3103 | STATE : code ROUTINE : aci_SrchFwrdLst |
3104 +--------------------------------------------------------------------+
3105 PURPOSE : This function is used to search for a specific string in
3106 the list of AT commands which will be forwarded if
3107 necessary.
3108 */
3109 LOCAL BOOL aci_SrchFwrdLst ( UBYTE srcId, CHAR* searchFor )
3110 {
3111 CHAR** pTmp;
3112 int i=0;
3113
3114 TRACE_FUNCTION ( "aci_SrchFwrdLst ()" );
3115
3116 if (ext_v2_flag EQ TRUE)
3117 {
3118 TRACE_EVENT ("New Extension Mechanism...");
3119 pTmp = atCmdFwrdLst_v2;
3120 }
3121 else
3122 {
3123 TRACE_EVENT ("Old Extension Mechanism...");
3124 pTmp = atCmdFwrdLst;
3125 }
3126
3127 if (pTmp)
3128 {
3129 while (*(pTmp+i) NEQ NULL)
3130 {
3131 if ( strcmp ( *(pTmp+i), searchFor ) EQ 0 )
3132 {
3133 TRACE_EVENT_P1 ( "aci_SrchFwrdLst(): %s found", searchFor);
3134 return TRUE;
3135 }
3136 i++;
3137 }
3138 }
3139 else
3140 {
3141 TRACE_EVENT( "aci_SrchFwrdLst(): atCmdFwrdLst does not exist");
3142 }
3143 return FALSE;
3144 }
3145 /*
3146 +--------------------------------------------------------------------+
3147 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3148 | STATE : code ROUTINE : aci_FwrdToEXT |
3149 +--------------------------------------------------------------------+
3150
3151 PURPOSE : This function is used to forward an AT command to the
3152 extension handler.
3153 */
3154 LOCAL T_ATI_RSLT aci_FwrdToEXT (T_ATI_SRC_PARAMS *src_params, T_LEDIT_ATCMD *cmd)
3155 {
3156 USHORT lenExt = 0;
3157 char *extCmd = NULL;
3158 T_ACI_RETURN extRslt = AT_FAIL;
3159
3160 TRACE_FUNCTION ( "aci_FwrdToEXT ()" );
3161
3162 ACI_MALLOC(extCmd, MAX_CMD_LEN);
3163 *extCmd = '\0';
3164
3165 if (src_id_ext NEQ 0xFF)
3166 {
3167 TRACE_EVENT("aci_FwrdToEXT(): src_id_ext has not been reset to 0xFF");
3168 }
3169
3170 /*
3171 * only this source can currently run extension commands
3172 * the reset to 0xFF takes place in ati_run_cmd_line() and rCI_PlusCME() (asynchronious case)
3173 */
3174 src_id_ext = src_params->src_id;
3175 /*
3176 * we have to build up the extension cmd in the same old manner before using of line edit
3177 */
3178 /* All sprintfs below are now replaced by strcats . Bug 18239 */
3179
3180 if(cmd->type.append_Flag EQ TRUE)
3181 {
3182 switch(cmd->type.sType)
3183 {
3184 case LEDIT_ATCMD_SET :
3185 {
3186 if ((strlen(cmd->params)) NEQ 0)
3187 {
3188 strcat(extCmd,cmd->name);
3189 strcat(extCmd,"=");
3190 strcat(extCmd,cmd->params);
3191 }
3192 else
3193 {
3194 strcat(extCmd,cmd->name);
3195 }
3196 break;
3197 }
3198
3199 case LEDIT_ATCMD_QUERY :
3200 {
3201 if ((strlen(cmd->params)) NEQ 0)
3202 {
3203 strcat(extCmd,cmd->name);
3204 strcat(extCmd,"?");
3205 strcat(extCmd,cmd->params);
3206 }
3207 else
3208 {
3209 strcat(extCmd,cmd->name);
3210 strcat(extCmd,"?");
3211 }
3212 break;
3213 }
3214
3215 case LEDIT_ATCMD_TEST:
3216 {
3217 if ((strlen(cmd->params)) NEQ 0)
3218 {
3219 strcat(extCmd,cmd->name);
3220 strcat(extCmd,"=");
3221 strcat(extCmd,"?");
3222 strcat(extCmd,cmd->params);
3223 }
3224 else
3225 {
3226 strcat(extCmd,cmd->name);
3227 strcat(extCmd,"=");
3228 strcat(extCmd,"?");
3229 }
3230 break;
3231 }
3232 }
3233 }
3234
3235 if(cmd->type.append_Flag EQ FALSE)
3236 {
3237 switch(cmd->type.sType)
3238 {
3239 case LEDIT_ATCMD_SET:
3240 case LEDIT_ATCMD_QUERY:
3241 case LEDIT_ATCMD_TEST:
3242 {
3243 strcat(extCmd,cmd->name);
3244 break;
3245 }
3246 default:
3247 {
3248 strcat(extCmd,cmd->name);
3249 break;
3250 }
3251 }
3252 }
3253
3254 lenExt = strlen(extCmd);
3255 TRACE_EVENT_P1("aci_FwrdToEXT(): Total Command Length %x ", lenExt);
3256
3257 if (strchr (OLD_NON_STANDARDIZED_ATCMD, extCmd[0]))
3258 {
3259 if (*extCmd EQ '&')
3260 {
3261 if (strchr (OLD_NON_STANDARDIZED_ATCMD, extCmd[1]) EQ NULL)
3262 {
3263 TRACE_EVENT("[ERR]aci_FwrdToEXT ()");
3264 cmdAtError (atError);
3265 ACI_MFREE(extCmd);
3266 return (ATI_FAIL);
3267 }
3268 }
3269 }
3270
3271 send_output_type_signal (src_params, ATI_OUTPUT_TYPE_NORMAL);
3272
3273 g_sa[0] = (CHAR) ACI_EXT_STRG_END;
3274
3275 TRACE_EVENT_P1("aci_FwrdToEXT(): running cmd %s", extCmd);
3276 if (ext_v2_flag EQ TRUE)
3277 {
3278 extRslt = rEXT_Execute (src_params->src_id, extCmd);
3279 }
3280 else
3281 {
3282 extRslt = rAT_EXT (extCmd, &lenExt, g_sa, MAX_CMD_LEN - 1);
3283 aci_sendPString (src_params->src_id, g_sa);
3284 }
3285
3286 ACI_MFREE(extCmd);
3287
3288 switch (extRslt)
3289 {
3290 case (AT_CMPL):
3291 {
3292 cmdErrStr = NULL;
3293 TRACE_EVENT("aci_FwrdToEXT(): returns with ATI_CMPL");
3294 return (ATI_CMPL);
3295 }
3296 case (AT_EXCT):
3297 {
3298 cmdErrStr = NULL;
3299 src_params->curAtCmd = AT_CMD_EXT;
3300 TRACE_EVENT("aci_FwrdToEXT(): returns with ATI_EXCT");
3301 return (ATI_EXCT);
3302 }
3303
3304 default:
3305 {
3306 cmdAtError (atError);
3307 TRACE_EVENT("aci_FwrdToEXT(): returns with ATI_FAIL");
3308 return (ATI_FAIL);
3309 }
3310 }
3311 }
3312
3313 /*
3314 +--------------------------------------------------------------------+
3315 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3316 | STATE : code ROUTINE : aci_cmhActive |
3317 +--------------------------------------------------------------------+
3318
3319 PURPOSE : This function is used to calculate whether the mobile is
3320 in service.
3321 */
3322 LOCAL BOOL aci_cmhActive ( UBYTE srcId )
3323 {
3324 BOOL rslt = FALSE;
3325 T_ACI_NRG_RGMD regMode;
3326 T_ACI_NRG_SVMD srvMode;
3327 T_ACI_NRG_FRMT oprFrmt;
3328 T_ACI_NRG_SVMD srvStat;
3329 CHAR oper[MAX_ALPHA_OPER_LEN];
3330
3331 TRACE_FUNCTION ( "aci_cmhActive ()" );
3332
3333 qAT_PercentNRG( srcId,
3334 &regMode,
3335 &srvMode,
3336 &oprFrmt,
3337 &srvStat,
3338 oper);
3339
3340 if ( srvStat EQ NRG_SVMD_Full OR
3341 srvStat EQ NRG_SVMD_Limited )
3342 {
3343 rslt = TRUE;
3344 }
3345
3346 return rslt;
3347 }
3348
3349 /*
3350 +--------------------------------------------------------------------+
3351 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3352 | STATE : code ROUTINE : ati_switch_mode |
3353 +--------------------------------------------------------------------+
3354
3355 PURPOSE : changes mode from command mode to data mode and vice-versa.
3356
3357 */
3358
3359 GLOBAL void ati_switch_mode (UBYTE srcId,
3360 T_ATI_IO_MODE mode)
3361 {
3362 T_ATI_SRC_PARAMS *src_params;
3363
3364 src_params = find_element (ati_src_list, srcId, search_ati_src_id);
3365 if (src_params EQ NULL)
3366 {
3367 TRACE_EVENT_P1 ("[ERR] io_sendMessage: srcId=%d not found", srcId);
3368 return;
3369 }
3370
3371 src_params->mode = mode;
3372
3373 if (mode EQ ATI_CMD_MODE)
3374 {
3375 TRACE_EVENT("IO mode changed to CMD MODE");
3376 cmd_flushCievBuf(src_params->src_id);
3377
3378 /* The CNMI buffer is flushed only if the current source
3379 * matches with the source interested in SMS indications */ /* Issue 25033 */
3380 if ( src_params->src_id EQ smsShrdPrm.smsSrcId )
3381 {
3382 /* If Service is not GSM phase 2+, flushing is done at once,
3383 because acknowledge is not necessary */
3384 if( smsShrdPrm.CSMSservice NEQ CSMS_SERV_GsmPh2Plus )
3385 {
3386 cmd_flushCnmiBuf();
3387 }
3388 else
3389 {
3390 cmd_flushCnmiBufOneByOne();
3391 }
3392 }
3393 }
3394 else
3395 {
3396 TRACE_EVENT("IO mode changed to DATA MODE");
3397 }
3398 }
3399
3400
3401 /*
3402 +--------------------------------------------------------------------+
3403 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD |
3404 | STATE : code ROUTINE : ati_get_mode |
3405 +--------------------------------------------------------------------+
3406
3407 PURPOSE : returns current IO-mode
3408 */
3409 GLOBAL T_ATI_IO_MODE ati_get_mode( UBYTE srcId )
3410 {
3411 T_ATI_SRC_PARAMS *src_params;
3412
3413 src_params = find_element (ati_src_list, srcId, search_ati_src_id);
3414 if (src_params EQ NULL)
3415 {
3416 TRACE_EVENT_P1 ("[ERR] io_sendMessage: srcId=%d not found", srcId);
3417 return ATI_UNKN_MODE;
3418 }
3419
3420 return( src_params->mode );
3421 }
3422
3423 /*
3424 +--------------------------------------------------------------------+
3425 | PROJECT : GSM-PS MODULE : ATI_IO |
3426 | STATE : code ROUTINE : format |
3427 +--------------------------------------------------------------------+
3428
3429 PURPOSE : format the ouput
3430
3431 */
3432
3433 GLOBAL USHORT format_output (UBYTE *src, USHORT src_len, UBYTE *dst,
3434 T_ATI_OUTPUT_TYPE output_type)
3435 {
3436 USHORT dst_len = 0;
3437
3438 if (at.s1415.atV)
3439 {
3440 /*
3441 * verbose mode
3442 */
3443 if (IS_BEGIN_CRLF_OUTPUT (output_type))
3444 {
3445 dst[0] = at.S[3];
3446 dst_len++;
3447 dst[1] = at.S[4];
3448 dst_len++;
3449 }
3450
3451 memcpy (dst + dst_len, src, src_len);
3452 dst_len += src_len;
3453
3454 if (IS_END_CRLF_OUTPUT (output_type))
3455 {
3456 dst[dst_len] = at.S[3];
3457 dst_len++;
3458 dst[dst_len] = at.S[4];
3459 dst_len++;
3460 }
3461
3462 return (dst_len);
3463 }
3464
3465 /*
3466 * non-verbose mode
3467 */
3468
3469 memcpy (dst + dst_len, src, src_len);
3470 dst_len += src_len;
3471
3472 if (IS_ECHO_OUTPUT (output_type))
3473 {
3474 return (dst_len);
3475 }
3476
3477 dst[dst_len] = at.S[3];
3478 dst_len++;
3479
3480 if (!(IS_CONFIRM_OUTPUT(output_type) OR IS_RESULT_CODE_OUTPUT(output_type)))
3481 {
3482 dst[dst_len] = at.S[4];
3483 dst_len++;
3484 }
3485
3486 return (dst_len);
3487 }
3488
3489 /*
3490 +--------------------------------------------------------------------+
3491 | PROJECT : GSM MODULE : ATI_RET |
3492 | STATE : code ROUTINE : ati_is_src_type |
3493 +--------------------------------------------------------------------+
3494
3495 PURPOSE : this function checks if the given source ID is of given type
3496 (example: is it a SAT source (for RUN AT COMMAND)
3497 */
3498
3499 GLOBAL BOOL ati_is_src_type( UBYTE srcId, T_ATI_SRC_TYPE source_type )
3500 {
3501 #ifdef SIM_TOOLKIT
3502 T_ATI_SRC_PARAMS *src_params;
3503 #endif /* SIM_TOOLKIT */
3504
3505 if (!IS_SRC_USED(srcId))
3506 {
3507 return(FALSE);
3508 }
3509
3510 #ifdef SIM_TOOLKIT
3511 src_params = find_element (ati_src_list, srcId, search_ati_src_id);
3512 if (src_params EQ NULL)
3513 {
3514 return FALSE;
3515 }
3516
3517 if( src_params->src_type EQ source_type )
3518 {
3519 TRACE_EVENT_P2("source %d is of type %d", srcId, source_type);
3520 return( TRUE );
3521 }
3522 else
3523 #endif /* SIM_TOOLKIT */ /* always returns FALSE if SIM_TOOLKIT isn't defined */
3524 {
3525 return( FALSE );
3526 }
3527 }
3528
3529
3530 /*
3531 PURPOSE :This function takes in the AT command string as input parameter and
3532 returns the corresponding command ID. This function provides an interface for
3533 get_command_id_in_wn_list () to get the command Id from a local table cmd[ ]
3534 with a command name string as input.
3535 */
3536
3537 GLOBAL T_ACI_AT_CMD get_command_id (CHAR *command_str)
3538 {
3539 int i;
3540 T_ACI_AT_CMD command = AT_CMD_NONE;
3541
3542 TRACE_FUNCTION ("get_command_id()");
3543
3544 for (i = 1; cmds [i].key NEQ NULL AND strcmp (cmds [i].key, command_str); i ++) { }
3545 command = cmds [i].binKey;
3546 TRACE_EVENT_P1 ("command Id is: %d", command);
3547 return (command);
3548 }
3549
3550 /*
3551 +--------------------------------------------------------------------+
3552 | PROJECT : GSM MODULE : ATI_CMD |
3553 | STATE : code ROUTINE : sEXT_Output |
3554 +--------------------------------------------------------------------+
3555
3556 PURPOSE : this function provides the interface for the extension mechanism to output
3557 messages to the source. If the message is too long the calling function can
3558 seperate the message into several parts and choose the right output type.
3559 */
3560
3561 GLOBAL T_ATI_RSLT sEXT_Output (UBYTE src_id, T_ATI_EXT_FORMAT output_format,
3562 CHAR *output)
3563 {
3564 T_ATI_SRC_PARAMS *src_params;
3565
3566 TRACE_FUNCTION ("sEXT_Output()");
3567 src_params = find_element (ati_src_list, src_id, search_ati_src_id);
3568 if (src_params EQ NULL)
3569 {
3570 TRACE_EVENT_P1 ("[ERR] sEXT_Output: srcId=%d not found", src_id);
3571 return ATI_FAIL;
3572 }
3573 /* if (src_id NEQ src_id_ext)
3574 {
3575 TRACE_EVENT ("[ERR] sEXT_Output: No extension command running.");
3576 return ATI_FAIL;
3577 } */
3578 switch (output_format)
3579 {
3580 case ATI_EXT_PART_BEGIN:
3581 io_sendMessageEx(src_id, output, ATI_NORMAL_OUTPUT|ATI_BEGIN_CRLF_OUTPUT );
3582 break;
3583 case ATI_EXT_PART_LAST:
3584 io_sendMessageEx(src_id, output, ATI_NORMAL_OUTPUT|ATI_END_CRLF_OUTPUT );
3585 break;
3586 case ATI_EXT_PART_LINE:
3587 io_sendMessageEx(src_id, output, ATI_NORMAL_OUTPUT);
3588 break;
3589 case ATI_EXT_CMPL_LINE:
3590 io_sendMessageEx(src_id, output, ATI_NORMAL_OUTPUT|ATI_END_CRLF_OUTPUT );
3591 break;
3592 default:
3593 return ATI_FAIL;
3594 }
3595 return ATI_CMPL;
3596 }
3597
3598
3599 /*
3600 +--------------------------------------------------------------------+
3601 | PROJECT : GSM MODULE : ATI_CMD |
3602 | STATE : code ROUTINE : sEXT_Indication |
3603 +--------------------------------------------------------------------+
3604
3605 PURPOSE : this function provides the interface for the extension mechanism to output
3606 indications (unsolistic output) to the source.
3607 */
3608
3609 GLOBAL T_ATI_RSLT sEXT_Indication (UBYTE src_id, CHAR *indication_string)
3610 {
3611 TRACE_FUNCTION ("sEXT_Indication()");
3612 if (indication_string EQ NULL)
3613 {
3614 TRACE_EVENT ("[ERR] sEXT_Indication: No indication string.");
3615 return ATI_FAIL;
3616 }
3617 if (src_id NEQ src_id_ext)
3618 {
3619 TRACE_EVENT ("[ERR] sEXT_Indication: No extension command is running.");
3620 return ATI_FAIL;
3621 }
3622 io_sendIndication(src_id, indication_string, ATI_FORCED_OUTPUT);
3623 return AT_CMPL;
3624 }
3625
3626 /*
3627 +--------------------------------------------------------------------+
3628 | PROJECT : GSM MODULE : ATI_CMD |
3629 | STATE : code ROUTINE : sEXT_Confirm |
3630 +--------------------------------------------------------------------+
3631
3632 PURPOSE : this function provides the interface for the extension mechanism to output
3633 a confirmations to the source. A confirmation should be sent in the cases
3634 where an AT command runs for a long time and only ATI_EXT_EXCT has
3635 been returned.
3636 */
3637 GLOBAL T_ATI_RSLT sEXT_Confirm (UBYTE src_id)
3638 {
3639 T_ATI_SRC_PARAMS *src_params;
3640 TRACE_FUNCTION ("sEXT_Confirm()");
3641
3642 src_params = find_element (ati_src_list, src_id, search_ati_src_id);
3643 if (src_params EQ NULL)
3644 {
3645 TRACE_EVENT_P1 ("[ERR] sEXT_Confirm: srcId=%d not found", src_id);
3646 return ATI_FAIL;
3647 }
3648 if (src_id NEQ src_id_ext)
3649 {
3650 TRACE_EVENT ("[ERR] sEXT_Confirm: No extension command running.");
3651 return ATI_FAIL;
3652 }
3653 TRACE_EVENT("Extension command signals a successful result.") ;
3654 srcId_cb = src_id;
3655 rCI_OK (AT_CMD_EXT);
3656 return ATI_CMPL;
3657 }
3658
3659 /*
3660 +--------------------------------------------------------------------+
3661 | PROJECT : GSM MODULE : ATI_CMD |
3662 | STATE : code ROUTINE : sEXT_Error |
3663 +--------------------------------------------------------------------+
3664
3665 PURPOSE : this function provides the interface for the extension mechanism to output
3666 an error message to the source. An error message should be sent in the
3667 cases where error happens or when an AT command runs for a long time
3668 and only ATI_EXT_EXCT has been returned before an error happens. By
3669 calling this function the AT interpreter will be freed to run a second command.
3670 */
3671 GLOBAL T_ATI_RSLT sEXT_Error (UBYTE src_id, T_ACI_CME_ERR err)
3672 {
3673 TRACE_FUNCTION ("sEXT_Error()");
3674 if (src_id NEQ src_id_ext)
3675 {
3676 TRACE_EVENT ("[ERR] sEXT_Error: No extension command running.");
3677 return ATI_FAIL;
3678 }
3679 srcId_cb = src_id;
3680 rCI_PlusCME (AT_CMD_EXT, err);
3681 return ATI_CMPL;
3682 }
3683
3684 /*
3685 +--------------------------------------------------------------------+
3686 | PROJECT : GSM MODULE : ATI_CMD |
3687 | STATE : code ROUTINE : sEXT_Init |
3688 +--------------------------------------------------------------------+
3689
3690 PURPOSE : this function provides the interface for the extension mechanism
3691 */
3692 GLOBAL T_ATI_RSLT sEXT_Init (CHAR *cmd_list[])
3693 {
3694 TRACE_FUNCTION("sEXT_Init()");
3695 if (*cmd_list EQ NULL)
3696 {
3697 TRACE_EVENT ("The old EXT mechanism will be used.");
3698 ext_v2_flag = FALSE;
3699 }
3700 else
3701 {
3702 TRACE_EVENT ("The new EXT mechanism will be used.");
3703 ext_v2_flag = TRUE;
3704 atCmdFwrdLst_v2 = cmd_list;
3705 }
3706 return ATI_CMPL;
3707 }
3708
3709 /*
3710 +--------------------------------------------------------------------+
3711 | PROJECT : GSM MODULE : ATI_CMD |
3712 | STATE : code ROUTINE : sEXT_finit |
3713 +--------------------------------------------------------------------+
3714
3715 PURPOSE : this function frees the memory of the extension command list
3716
3717 GLOBAL T_ATI_RSLT sEXT_Finit ()
3718 {
3719 ACI_MFREE(atCmdFwrdLst);
3720 return ATI_CMPL;
3721 }*/
3722 #endif /* ATI_CMD_C */
3723