FreeCalypso > hg > fc-selenite

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

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