FreeCalypso > hg > fc-tourmaline

comparison src/g23m-aci/aci/ati_cmd.c @ 1:fa8dc04885d8

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