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