FreeCalypso > hg > fc-magnetite

comparison src/g23m-aci/aci/ati_cmd.c @ 162:53929b40109c

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