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