FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/ati_cmd.c @ 0:75a11d740a02

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