FreeCalypso > hg > freecalypso-citrine
comparison g23m-aci/aci/ati_mm.c @ 0:75a11d740a02
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Thu, 09 Jun 2016 00:02:41 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:75a11d740a02 |
---|---|
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: Mobility Management related functions. | |
18 +----------------------------------------------------------------------------- | |
19 */ | |
20 | |
21 #ifndef ATI_MM_C | |
22 #define ATI_MM_C | |
23 | |
24 #include "config.h" | |
25 #include "fixedconf.h" | |
26 #include "condat-features.h" | |
27 #include "aci_conf.h" | |
28 | |
29 #undef DUMMY_ATI_STRINGS | |
30 | |
31 #include "aci_all.h" | |
32 | |
33 #include "aci_lst.h" | |
34 #include "aci_cmh.h" | |
35 #include "ati_cmd.h" | |
36 #include "aci_io.h" | |
37 #include "aci_cmd.h" | |
38 #include "l4_tim.h" | |
39 | |
40 #include "aci_mem.h" | |
41 #include "aci_prs.h" | |
42 | |
43 #include "ati_int.h" | |
44 | |
45 #ifdef UART | |
46 #include "dti.h" | |
47 #include "dti_conn_mng.h" | |
48 #endif | |
49 | |
50 #include "psa.h" | |
51 #include "cmh.h" | |
52 #include "psa_sim.h" | |
53 #include "cmh_sim.h" | |
54 #include "psa_mm.h" | |
55 | |
56 #ifdef FF_ATI_BAT | |
57 | |
58 #include "typedefs.h" | |
59 #include "gdd.h" | |
60 #include "bat.h" | |
61 | |
62 #include "ati_bat.h" | |
63 | |
64 #endif /* FF_ATI_BAT */ | |
65 | |
66 EXTERN T_ACI_CFUN_FUN CFUNfun; | |
67 EXTERN T_CIEV_SIGNAL_BUFFER asCievSignalBuf; | |
68 EXTERN T_CIEV_SMSFULL_BUFFER asCievSmsFullBuf; | |
69 | |
70 /* | |
71 +--------------------------------------------------------------------+ | |
72 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
73 | STATE : code ROUTINE : atPlusCops | | |
74 +--------------------------------------------------------------------+ | |
75 | |
76 PURPOSE : +COPS command (operator selection) | |
77 */ | |
78 | |
79 GLOBAL T_ATI_RSLT setatPlusCOPS (char *cl, UBYTE srcId) | |
80 { | |
81 CHAR op[MAX_ALPHA_OPER_LEN] = {0}; | |
82 T_ACI_RETURN ret = AT_FAIL; | |
83 T_ACI_COPS_MOD mode = COPS_MOD_NotPresent; | |
84 T_ACI_COPS_FRMT format = COPS_FRMT_NotPresent; | |
85 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
86 | |
87 TRACE_FUNCTION("setatPlusCops()"); | |
88 | |
89 if (CFUNfun NEQ CFUN_FUN_Full) | |
90 { | |
91 TRACE_EVENT_P1("+COPS error: cannot proceed Mobile has no Full CFUN: %d", CFUNfun); | |
92 cmdCmeError(CME_ERR_OpNotAllow); | |
93 return ATI_FAIL; | |
94 } | |
95 | |
96 cl = parse (cl,"dds",&mode,&format,(LONG)(MAX_ALPHA_OPER_LEN-1),op); /*split parameter string in int,int,str*/ | |
97 if (!cl OR ((mode EQ COPS_MOD_Man OR mode EQ COPS_MOD_Both) | |
98 AND op[0] EQ 0)) | |
99 { | |
100 cmdCmeError(CME_ERR_OpNotAllow); | |
101 return ATI_FAIL; | |
102 } | |
103 | |
104 #ifdef FF_ATI_BAT | |
105 { | |
106 T_BAT_cmd_send cmd; | |
107 T_BAT_cmd_set_plus_cops cops; | |
108 UBYTE len; | |
109 | |
110 len=strlen(op); | |
111 | |
112 /* | |
113 * If the operator name is too long we can't really do anything | |
114 * meaningful, so generate an error and give up. | |
115 */ | |
116 if (len>BAT_MAX_COPS_OPER_LEN) | |
117 { | |
118 cmdCmeError(CME_ERR_Unknown); | |
119 return(ATI_FAIL); | |
120 } | |
121 | |
122 cmd.ctrl_params = BAT_CMD_SET_PLUS_COPS; | |
123 cmd.params.ptr_set_plus_cops=&cops; | |
124 | |
125 /* | |
126 * This relies on T_ACI_COPS_MOD and T_BAT_plus_cops_mode being | |
127 * equivalent. | |
128 */ | |
129 cops.mode=(T_BAT_plus_cops_mode)mode; | |
130 | |
131 /* | |
132 * This relies on T_ACI_COPS_FRMT and T_BAT_plus_cops_format being | |
133 * equivalent. | |
134 */ | |
135 cops.format=(T_BAT_plus_cops_format)format; | |
136 | |
137 cops.c_oper=(U8)len; | |
138 | |
139 if (len) | |
140 { | |
141 memcpy(cops.oper,op,BAT_MAX_COPS_OPER_LEN); | |
142 cops.v_oper=TRUE; | |
143 } | |
144 else | |
145 { | |
146 cops.v_oper=FALSE; | |
147 } | |
148 bat_send(ati_bat_get_client(srcId), &cmd); | |
149 src_params->curAtCmd = AT_CMD_COPS; | |
150 return ATI_EXCT; | |
151 } | |
152 #else | |
153 | |
154 ret = sAT_PlusCOPS ((T_ACI_CMD_SRC)srcId,mode,format,op); | |
155 switch (ret) | |
156 { | |
157 case (AT_CMPL): /*operation completed*/ | |
158 break; | |
159 case (AT_EXCT): | |
160 src_params->curAtCmd = AT_CMD_COPS; | |
161 break; | |
162 default: | |
163 cmdCmeError(CME_ERR_Unknown); /*Command failed*/ | |
164 break; | |
165 } | |
166 return (map_aci_2_ati_rslt(ret)); | |
167 | |
168 #endif /*FF_ATI_BAT*/ | |
169 } | |
170 | |
171 #ifdef FF_ATI_BAT | |
172 /* | |
173 +--------------------------------------------------------------------+ | |
174 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
175 | STATE : code ROUTINE : aci_bat_HandleTestCOPS | | |
176 +--------------------------------------------------------------------+ | |
177 | |
178 PURPOSE : | |
179 */ | |
180 T_ATI_RSLT atiHandleTestCOPS(UBYTE srcId) | |
181 { | |
182 T_BAT_cmd_send cmd; | |
183 T_BAT_no_parameter dummy; | |
184 | |
185 cmd.ctrl_params = BAT_CMD_TST_PERCENT_COPS; | |
186 dummy.bat_dummy = 0xFF; | |
187 cmd.params.ptr_que_plus_cops = &dummy; | |
188 | |
189 TRACE_FUNCTION("aci_bat_HandleTestCOPS() calls bat_send() <=== as APPLICATION"); | |
190 | |
191 #ifndef FF_DUAL_SIM | |
192 if (CFUNfun NEQ CFUN_FUN_Full) | |
193 { | |
194 cmdCmeError(CME_ERR_OpNotAllow); | |
195 return ATI_FAIL; | |
196 } | |
197 #endif /*FF_DUAL_SIM*/ | |
198 | |
199 bat_send(ati_bat_get_client(srcId), &cmd); | |
200 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
201 } | |
202 | |
203 #else /* no FF_ATI_BAT */ | |
204 | |
205 GLOBAL T_ATI_RSLT atiHandleTestCOPS(char *cl, UBYTE srcId) | |
206 { | |
207 T_ACI_RETURN ret = AT_FAIL; | |
208 SHORT startIdx = 0, | |
209 lastIdx = 0, | |
210 i; | |
211 T_ACI_COPS_LST operLst; | |
212 BOOL END_OF_LIST = FALSE; | |
213 | |
214 | |
215 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
216 char* outputCommand; | |
217 | |
218 | |
219 TRACE_FUNCTION("atiHandleTestCOPS()"); | |
220 | |
221 #ifndef FF_DUAL_SIM | |
222 if (CFUNfun NEQ CFUN_FUN_Full) | |
223 { | |
224 cmdCmeError(CME_ERR_OpNotAllow); | |
225 return ATI_FAIL; | |
226 } | |
227 #endif /*FF_DUAL_SIM*/ | |
228 do | |
229 { | |
230 startIdx += lastIdx; | |
231 switch (src_params->curAtCmd) | |
232 { | |
233 case AT_CMD_COPS: | |
234 ret = tAT_PlusCOPS((T_ACI_CMD_SRC)srcId,startIdx,&lastIdx,&operLst[0]); | |
235 break; | |
236 case AT_CMD_P_COPS: | |
237 ret = tAT_PercentCOPS((T_ACI_CMD_SRC)srcId,startIdx,&lastIdx,&operLst[0]); | |
238 break; | |
239 default: | |
240 cmdCmeError(CME_ERR_Unknown); | |
241 return ATI_FAIL; | |
242 } | |
243 if (ret EQ AT_CMPL) | |
244 { | |
245 for(i=0;i<lastIdx;i++) | |
246 { | |
247 if ((operLst[i].status < 0) AND (*operLst[i].numOper EQ 0)) | |
248 { | |
249 END_OF_LIST = TRUE; | |
250 break; | |
251 } | |
252 | |
253 /* What COPS command is active? */ | |
254 switch (src_params->curAtCmd) | |
255 { | |
256 case AT_CMD_COPS: | |
257 outputCommand = "+COPS"; | |
258 break; | |
259 case AT_CMD_P_COPS: | |
260 outputCommand ="%COPS"; | |
261 break; | |
262 default: | |
263 cmdCmeError(CME_ERR_Unknown); | |
264 return ATI_FAIL; | |
265 } | |
266 | |
267 sprintf(g_sa,"%s: %d,\"%s\",\"%s\",%s",outputCommand, | |
268 operLst[i].status,operLst[i].longOper, | |
269 operLst[i].shortOper,operLst[i].numOper); | |
270 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
271 | |
272 } | |
273 } | |
274 | |
275 switch(ret) | |
276 { | |
277 case AT_EXCT: | |
278 return ATI_EXCT; | |
279 | |
280 case AT_FAIL: | |
281 cmdCmeError(CME_ERR_Unknown); | |
282 return ATI_FAIL; | |
283 | |
284 case AT_BUSY: | |
285 return ATI_BUSY; | |
286 | |
287 default: | |
288 break;/* Does nothing in this case */ | |
289 } | |
290 | |
291 } | |
292 while(!END_OF_LIST); | |
293 | |
294 return ATI_CMPL; | |
295 } | |
296 | |
297 #endif /* no FF_ATI_BAT */ | |
298 | |
299 | |
300 GLOBAL T_ATI_RSLT tesatPlusCOPS (char *cl, UBYTE srcId) | |
301 { | |
302 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
303 | |
304 #ifdef FF_ATI_BAT | |
305 TRACE_FUNCTION("tesatPlusCOPS() calls bat_send() <=== as APPLICATION"); | |
306 return atiHandleTestCOPS(srcId); | |
307 | |
308 #else /* FF_ATI_BAT */ | |
309 TRACE_FUNCTION("tesatPlusCOPS()"); | |
310 return atiHandleTestCOPS(cl,srcId); | |
311 #endif /* FF_ATI_BAT */ | |
312 | |
313 } | |
314 | |
315 GLOBAL T_ATI_RSLT queatPlusCOPS (char *cl, UBYTE srcId) | |
316 { | |
317 CHAR op[MAX_ALPHA_OPER_LEN] = {0}; | |
318 T_ACI_RETURN ret = AT_FAIL; | |
319 T_ACI_COPS_MOD mode = COPS_MOD_NotPresent; | |
320 T_ACI_COPS_FRMT format = COPS_FRMT_NotPresent; | |
321 | |
322 TRACE_FUNCTION("queatPlusCops()"); | |
323 | |
324 #ifdef FF_ATI_BAT | |
325 { | |
326 T_BAT_cmd_send cmd; | |
327 T_BAT_no_parameter dummy; | |
328 | |
329 cmd.ctrl_params = BAT_CMD_QUE_PLUS_COPS; | |
330 dummy.bat_dummy = 0xFF; | |
331 cmd.params.ptr_que_plus_cops = &dummy; | |
332 bat_send(ati_bat_get_client(srcId), &cmd); | |
333 return(ATI_EXCT); | |
334 } | |
335 #else /* no FF_ATI_BAT */ | |
336 | |
337 ret = qAT_PlusCOPS((T_ACI_CMD_SRC)srcId,&mode,&format,op); | |
338 if (ret EQ AT_CMPL) | |
339 { | |
340 if (*op) | |
341 sprintf(g_sa,"+COPS: %d,%d,\"%s\"",mode,format,op); | |
342 else | |
343 sprintf(g_sa,"+COPS: %d",mode); | |
344 | |
345 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
346 } | |
347 else | |
348 { | |
349 cmdCmeError(CME_ERR_Unknown); | |
350 } | |
351 return (map_aci_2_ati_rslt(ret)); | |
352 | |
353 #endif /* no FF_ATI_BAT */ | |
354 } | |
355 | |
356 /* | |
357 +--------------------------------------------------------------------+ | |
358 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
359 | STATE : code ROUTINE : setatPercentCOPS | | |
360 +--------------------------------------------------------------------+ | |
361 | |
362 PURPOSE : %COPS command (operator selection) | |
363 */ | |
364 | |
365 GLOBAL T_ATI_RSLT setatPercentCOPS (char *cl, UBYTE srcId) | |
366 { | |
367 CHAR op[MAX_ALPHA_OPER_LEN] = {0}; | |
368 T_ACI_RETURN ret = AT_FAIL; | |
369 T_ACI_COPS_MOD mode = COPS_MOD_NotPresent; | |
370 T_ACI_COPS_FRMT format = COPS_FRMT_NotPresent; | |
371 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
372 | |
373 if (CFUNfun NEQ CFUN_FUN_Full) | |
374 { | |
375 TRACE_EVENT_P1("%COPS error: cannot proceed Mobile has no Full CFUN: %d", CFUNfun); | |
376 cmdCmeError(CME_ERR_OpNotAllow); | |
377 return ATI_FAIL; | |
378 } | |
379 cl = parse (cl,"dds",&mode,&format,(LONG)(MAX_ALPHA_OPER_LEN-1),op); /*split parameter string in int,int,str*/ | |
380 if (!cl) /*For %COPS, Manual selection without Operator parameter is allowed */ | |
381 { | |
382 cmdCmeError(CME_ERR_OpNotAllow); | |
383 return ATI_FAIL; | |
384 } | |
385 | |
386 #ifdef FF_ATI_BAT | |
387 { | |
388 T_BAT_cmd_send cmd; | |
389 T_BAT_cmd_set_percent_cops my_bat_set_percent_cops; | |
390 UBYTE OperLength = strlen(op); | |
391 | |
392 TRACE_FUNCTION("setatPercentCOPS() calls bat_send() <=== as APPLICATION"); | |
393 | |
394 memset(&my_bat_set_percent_cops, sizeof(my_bat_set_percent_cops), FALSE); | |
395 cmd.ctrl_params = BAT_CMD_SET_PERCENT_COPS; | |
396 cmd.params.ptr_set_percent_cops = &my_bat_set_percent_cops; | |
397 | |
398 my_bat_set_percent_cops.mode = (T_BAT_VAL_percent_cops_mode)mode; | |
399 my_bat_set_percent_cops.format = (T_BAT_VAL_percent_cops_format)format; | |
400 | |
401 if (OperLength NEQ 0 AND | |
402 OperLength <= BAT_MAX_COPS_LONG_OPER_LEN) | |
403 { | |
404 memcpy(&my_bat_set_percent_cops.oper, op, BAT_MAX_COPS_LONG_OPER_LEN); | |
405 } | |
406 | |
407 src_params->curAtCmd = AT_CMD_P_COPS; | |
408 | |
409 bat_send(ati_bat_get_client(srcId), &cmd); | |
410 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
411 } | |
412 | |
413 #else /* no FF_ATI_BAT */ | |
414 | |
415 TRACE_FUNCTION("setatPercentCOPS()"); | |
416 ret = sAT_PercentCOPS ((T_ACI_CMD_SRC)srcId,mode,format,op); | |
417 switch (ret) | |
418 { | |
419 case (AT_CMPL): /*operation completed*/ | |
420 break; | |
421 case (AT_EXCT): | |
422 src_params->curAtCmd = AT_CMD_P_COPS; | |
423 break; | |
424 default: | |
425 cmdCmeError(CME_ERR_Unknown); /*Command failed*/ | |
426 break; | |
427 } | |
428 return (map_aci_2_ati_rslt(ret)); | |
429 | |
430 #endif /* no FF_ATI_BAT */ | |
431 } | |
432 | |
433 | |
434 /* | |
435 +--------------------------------------------------------------------+ | |
436 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
437 | STATE : code ROUTINE : tesatPercentCOPS | | |
438 +--------------------------------------------------------------------+ | |
439 | |
440 PURPOSE : %COPS command (operator test) | |
441 */ | |
442 | |
443 | |
444 GLOBAL T_ATI_RSLT tesatPercentCOPS (char *cl, UBYTE srcId) | |
445 { | |
446 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
447 | |
448 #ifdef FF_ATI_BAT | |
449 TRACE_FUNCTION("tesatPercentCOPS() calls bat_send() <=== as APPLICATION"); | |
450 return atiHandleTestCOPS(srcId); | |
451 | |
452 #else /* FF_ATI_BAT */ | |
453 TRACE_FUNCTION("tesatPercentCOPS()"); | |
454 return atiHandleTestCOPS(cl,srcId); | |
455 #endif /* FF_ATI_BAT */ | |
456 } | |
457 | |
458 /* | |
459 +--------------------------------------------------------------------+ | |
460 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
461 | STATE : code ROUTINE : queatPercentCOPS | | |
462 +--------------------------------------------------------------------+ | |
463 | |
464 PURPOSE : %COPS command (operator query) | |
465 */ | |
466 | |
467 | |
468 GLOBAL T_ATI_RSLT queatPercentCOPS (char *cl, UBYTE srcId) | |
469 { | |
470 CHAR op[MAX_ALPHA_OPER_LEN] = {0}; | |
471 T_ACI_RETURN ret = AT_FAIL; | |
472 T_ACI_COPS_MOD mode = COPS_MOD_NotPresent; | |
473 T_ACI_COPS_FRMT format = COPS_FRMT_NotPresent; | |
474 T_ACI_COPS_SVST svrStatus = COPS_SVST_NotPresent; | |
475 | |
476 #ifdef FF_ATI_BAT | |
477 { | |
478 T_BAT_cmd_send cmd; | |
479 T_BAT_no_parameter dummy; | |
480 | |
481 TRACE_FUNCTION("queatPercentCOPS() calls bat_send() <=== as APPLICATION"); | |
482 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_COPS; | |
483 dummy.bat_dummy = 0xFF; | |
484 cmd.params.ptr_que_percent_cops = &dummy; | |
485 bat_send(ati_bat_get_client(srcId), &cmd); | |
486 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
487 } | |
488 #else /* no FF_ATI_BAT */ | |
489 | |
490 TRACE_FUNCTION("queatPercentCOPS()"); | |
491 | |
492 ret = qAT_PercentCOPS((T_ACI_CMD_SRC)srcId,&mode,&format,&svrStatus,op); | |
493 if (ret EQ AT_CMPL) | |
494 { | |
495 /* Added an empty comma and the service Status parameter */ | |
496 sprintf(g_sa,"%s: %d,%d,\"%s\",,%d","%COPS",mode,format,op,svrStatus); | |
497 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
498 | |
499 } | |
500 else | |
501 { | |
502 cmdCmeError(CME_ERR_Unknown); /*command failed*/ | |
503 } | |
504 return (map_aci_2_ati_rslt(ret)); | |
505 | |
506 #endif /* no FF_ATI_BAT */ | |
507 } | |
508 | |
509 | |
510 | |
511 /* | |
512 +--------------------------------------------------------------------+ | |
513 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
514 | STATE : code ROUTINE : setatPercentCREG | | |
515 +--------------------------------------------------------------------+ | |
516 | |
517 PURPOSE : %CREG command (Network registration) | |
518 */ | |
519 | |
520 GLOBAL T_ATI_RSLT setatPercentCREG (char *cl, UBYTE srcId) | |
521 { | |
522 T_ATI_CREG_MOD mode=CREG_MOD_OFF; | |
523 | |
524 TRACE_FUNCTION("setatPercentCREG()"); | |
525 | |
526 cl=parse(cl,"d",&mode); | |
527 | |
528 switch(mode) | |
529 { | |
530 case CREG_MOD_OFF: | |
531 case CREG_MOD_ON: | |
532 case CREG_MOD_LOC_INF_ON: | |
533 /* user wants to set mode: reset CREG related ATI parameters */ | |
534 ati_creg_init(srcId, PercentCREG_CMD); | |
535 ati_user_output_cfg[srcId].percent_creg.mod_lac_cid.pres_mode = mode; | |
536 return ATI_CMPL; | |
537 | |
538 default: | |
539 cmdCmeError(CME_ERR_OpNotAllow); | |
540 return ATI_FAIL; | |
541 } | |
542 } | |
543 | |
544 | |
545 /* | |
546 +--------------------------------------------------------------------+ | |
547 | PROJECT : GPRS (8441) MODULE : GACI_CMD | | |
548 | STATE : code ROUTINE : queatPercentCREG | | |
549 +--------------------------------------------------------------------+ | |
550 | |
551 PURPOSE : %CREG command | |
552 */ | |
553 GLOBAL T_ATI_RSLT queatPercentCREG (char *cl, UBYTE srcId) | |
554 { | |
555 | |
556 #ifndef FF_ATI_BAT | |
557 T_ACI_CREG_STAT stat; | |
558 USHORT lac, cid; | |
559 T_ATI_CREG_MOD mode; | |
560 T_ACI_P_CREG_GPRS_IND gprs_ind; | |
561 short pos; | |
562 U8 rt; | |
563 #endif | |
564 | |
565 TRACE_FUNCTION("queatPercentCREG()"); | |
566 | |
567 #ifdef FF_ATI_BAT | |
568 { | |
569 T_BAT_cmd_send cmd; | |
570 T_BAT_no_parameter dummy; | |
571 | |
572 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_CREG; | |
573 dummy.bat_dummy = 0xFF; | |
574 cmd.params.ptr_que_percent_creg = &dummy; | |
575 bat_send(ati_bat_get_client(srcId), &cmd); | |
576 return(ATI_EXCT); | |
577 } | |
578 #else /* no FF_ATI_BAT */ | |
579 | |
580 mode = ati_user_output_cfg[srcId].percent_creg.mod_lac_cid.pres_mode; | |
581 | |
582 if (qAT_PercentCREG((T_ACI_CMD_SRC)srcId, &stat, &lac, &cid, &gprs_ind, &rt) NEQ AT_CMPL) | |
583 { | |
584 cmdCmeError(CME_ERR_Unknown); | |
585 return ATI_FAIL; | |
586 } | |
587 | |
588 pos = sprintf(g_sa, "%s: %d,%d", "%CREG", mode, stat); | |
589 | |
590 if ( (mode EQ CREG_MOD_LOC_INF_ON) AND | |
591 (stat EQ CREG_STAT_Reg OR stat EQ CREG_STAT_Roam) ) | |
592 pos += sprintf(g_sa+pos, ",\"%04X\",\"%04X\"", lac, cid); | |
593 else | |
594 pos += sprintf(g_sa+pos, ",,"); | |
595 | |
596 sprintf(g_sa+pos,",%d", gprs_ind); | |
597 | |
598 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
599 return ATI_CMPL; | |
600 | |
601 #endif /* no FF_ATI_BAT */ | |
602 } | |
603 | |
604 /* | |
605 +--------------------------------------------------------------------+ | |
606 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
607 | STATE : code ROUTINE : setatPlusCREG | | |
608 +--------------------------------------------------------------------+ | |
609 | |
610 PURPOSE : +CREG command (Network registration) | |
611 */ | |
612 | |
613 GLOBAL T_ATI_RSLT setatPlusCREG (char *cl, UBYTE srcId) | |
614 { | |
615 T_ATI_CREG_MOD mode=CREG_MOD_OFF; | |
616 | |
617 TRACE_FUNCTION("setatPlusCREG()"); | |
618 | |
619 cl=parse(cl,"d",&mode); | |
620 | |
621 switch(mode) | |
622 { | |
623 case CREG_MOD_OFF: | |
624 case CREG_MOD_ON: | |
625 case CREG_MOD_LOC_INF_ON: | |
626 /* user wants to set mode: reset CREG related ATI parameters */ | |
627 ati_creg_init(srcId, CREG_CMD); | |
628 ati_user_output_cfg[srcId].creg.mod_lac_cid.pres_mode = mode; | |
629 return ATI_CMPL; | |
630 | |
631 default: | |
632 cmdCmeError(CME_ERR_OpNotAllow); | |
633 return ATI_FAIL; | |
634 } | |
635 } | |
636 | |
637 GLOBAL T_ATI_RSLT queatPlusCREG (char *cl, UBYTE srcId) | |
638 { | |
639 T_ACI_CREG_STAT stat; | |
640 USHORT lac, cid; | |
641 T_ATI_CREG_MOD mode; | |
642 short pos; | |
643 | |
644 TRACE_FUNCTION("queatPlusCREG()"); | |
645 | |
646 mode = ati_user_output_cfg[srcId].creg.mod_lac_cid.pres_mode; | |
647 | |
648 if (qAT_PlusCREG((T_ACI_CMD_SRC)srcId, &stat, &lac, &cid) NEQ AT_CMPL) | |
649 { | |
650 cmdCmeError(CME_ERR_Unknown); | |
651 return ATI_FAIL; | |
652 } | |
653 | |
654 pos = sprintf(g_sa, "+CREG: %d,%d", mode, stat); | |
655 | |
656 if (mode EQ CREG_MOD_LOC_INF_ON) | |
657 { | |
658 if (stat EQ CREG_STAT_Reg OR stat EQ CREG_STAT_Roam) | |
659 sprintf(g_sa+pos, ",\"%04X\",\"%04X\"", lac, cid); | |
660 } | |
661 | |
662 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
663 return ATI_CMPL; | |
664 } | |
665 | |
666 | |
667 | |
668 | |
669 /* | |
670 +--------------------------------------------------------------------+ | |
671 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
672 | STATE : code ROUTINE : atPlusCopn | | |
673 +--------------------------------------------------------------------+ | |
674 | |
675 PURPOSE : +COPN command (read operator names) | |
676 */ | |
677 | |
678 GLOBAL T_ATI_RSLT setatPlusCOPN (char *cl, UBYTE srcId) | |
679 { | |
680 SHORT startIdx, lastIdx; | |
681 T_ACI_COPN_LST operLst; | |
682 UBYTE idx; | |
683 BOOL loop; | |
684 BOOL ret; | |
685 | |
686 TRACE_FUNCTION("setatPlusCOPN()"); | |
687 | |
688 /* read out the PCM list */ | |
689 startIdx = 0; | |
690 loop = TRUE; | |
691 | |
692 do | |
693 { | |
694 if ( qAT_PlusCOPN((T_ACI_CMD_SRC)srcId, COPN_LID_Pcm, startIdx, | |
695 &lastIdx, operLst) EQ AT_FAIL ) | |
696 break; | |
697 | |
698 for( idx=0; idx < MAX_OPER; idx++ ) | |
699 { | |
700 if ( operLst[idx].numOper[0] EQ 0x0 ) | |
701 { | |
702 loop = FALSE; | |
703 break; | |
704 } | |
705 | |
706 sprintf(g_sa,"+COPN: \"%s\",\"%s\"",operLst[idx].numOper, | |
707 operLst[idx].alphaOper ); | |
708 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
709 } | |
710 startIdx = lastIdx+1; | |
711 } | |
712 while( loop ); | |
713 | |
714 /* read out the constant list */ | |
715 startIdx = 0; | |
716 | |
717 ret = cmd_readCOPNBlock(startIdx,srcId); | |
718 | |
719 if (ret EQ TRUE) | |
720 return ATI_CMPL; | |
721 else | |
722 return ATI_EXCT; | |
723 | |
724 } | |
725 | |
726 /* | |
727 +--------------------------------------------------------------------+ | |
728 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
729 | STATE : code ROUTINE : setatPercentCOPN | | |
730 +--------------------------------------------------------------------+ | |
731 | |
732 PURPOSE : %COPN command (get MCC and MNC, long name or short name given one of the them) | |
733 */ | |
734 | |
735 GLOBAL T_ATI_RSLT setatPercentCOPN (char *cl, UBYTE srcId) | |
736 { | |
737 T_ACI_COPS_FRMT format = COPS_FRMT_NotPresent; | |
738 CHAR op[MAX_ALPHA_OPER_LEN] = {0}; | |
739 T_ACI_OPER_NTRY * oper_ntry; | |
740 USHORT i; | |
741 | |
742 TRACE_FUNCTION ("setatPercentCOPN()"); | |
743 | |
744 cl = parse (cl,"ds", &format, (LONG)MAX_ALPHA_OPER_LEN, op); | |
745 | |
746 if ((!cl) OR (format < COPS_FRMT_Long) OR (format > COPS_FRMT_Numeric) OR *op EQ '\0') | |
747 { | |
748 cmdCmeError(CME_ERR_OpNotAllow); | |
749 return ATI_FAIL; | |
750 } | |
751 | |
752 if (format EQ COPS_FRMT_Numeric) | |
753 { | |
754 if ((strlen(op) NEQ (SIZE_MNC + SIZE_MCC -1)) AND | |
755 (strlen(op) NEQ (SIZE_MNC + SIZE_MCC))) | |
756 { | |
757 cmdCmeError(CME_ERR_OpNotAllow); | |
758 return ATI_FAIL; | |
759 } | |
760 | |
761 for (i = 0; *(op+i) NEQ '\0'; i ++) | |
762 { | |
763 if (!((*(op+i) >= '0')AND(*(op+i) <= '9'))) | |
764 { | |
765 cmdCmeError(CME_ERR_OpNotAllow); | |
766 return ATI_FAIL; | |
767 } | |
768 } | |
769 } | |
770 | |
771 ACI_MALLOC (oper_ntry, sizeof (T_ACI_OPER_NTRY)); | |
772 | |
773 if (qAT_PercentCOPN( (T_ACI_CMD_SRC)srcId, format, op, oper_ntry) EQ AT_FAIL) | |
774 { | |
775 sprintf (g_sa, "%s", "%COPN: "); | |
776 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
777 ACI_MFREE (oper_ntry); | |
778 return ATI_CMPL; | |
779 } | |
780 | |
781 if ((oper_ntry->mnc & 0x00F) EQ 0xF) | |
782 { | |
783 sprintf (g_sa, "%s\"%s\",\"%s\",\"%03X%02X\",%d", "%COPN: ", oper_ntry->longName, oper_ntry->shrtName, | |
784 oper_ntry->mcc, oper_ntry->mnc >> 4, oper_ntry->source); | |
785 } | |
786 else | |
787 { | |
788 sprintf (g_sa, "%s\"%s\",\"%s\",\"%03X%03X\",%d", "%COPN: ", oper_ntry->longName, oper_ntry->shrtName, | |
789 oper_ntry->mcc, oper_ntry->mnc, oper_ntry->source); | |
790 } | |
791 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
792 | |
793 ACI_MFREE (oper_ntry); | |
794 return ATI_CMPL; | |
795 | |
796 | |
797 } | |
798 | |
799 #ifdef TI_PS_FF_AT_CMD_WS46 | |
800 /* | |
801 +--------------------------------------------------------------------+ | |
802 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
803 | STATE : code ROUTINE : atPlusWS46 | | |
804 +--------------------------------------------------------------------+ | |
805 | |
806 PURPOSE : +WS46 command (select wireless network) | |
807 */ | |
808 | |
809 GLOBAL T_ATI_RSLT setatPlusWS46 (char *cl, UBYTE srcId) | |
810 { | |
811 T_ACI_RETURN ret = AT_FAIL; | |
812 T_ACI_WS46_MOD mode=WS46_MOD_NotPresent; | |
813 | |
814 TRACE_FUNCTION("setatPLusWS46()"); | |
815 | |
816 cl = parse(cl,"d",&mode); | |
817 if (!cl) | |
818 { | |
819 cmdCmeError(CME_ERR_OpNotAllow); | |
820 return ATI_FAIL; | |
821 } | |
822 | |
823 #ifdef FF_ATI_BAT | |
824 | |
825 { | |
826 T_BAT_cmd_send cmd; | |
827 T_BAT_cmd_set_plus_ws46 ws46; | |
828 | |
829 cmd.ctrl_params = BAT_CMD_SET_PLUS_WS46; | |
830 cmd.params.ptr_set_plus_ws46=&ws46; | |
831 | |
832 ws46.n=(T_BAT_plus_ws46_n)mode; | |
833 | |
834 bat_send(ati_bat_get_client(srcId), &cmd); | |
835 return(ATI_EXCT); | |
836 } | |
837 | |
838 #else /* no FF_ATI_BAT */ | |
839 | |
840 ret=sAT_PlusWS46((T_ACI_CMD_SRC)srcId,mode); | |
841 | |
842 if (ret EQ AT_CMPL) | |
843 { | |
844 return ATI_CMPL; | |
845 } | |
846 else | |
847 { | |
848 cmdCmeError(CME_ERR_OpNotAllow); | |
849 return ATI_FAIL; | |
850 } | |
851 | |
852 #endif /* no FF_ATI_BAT */ | |
853 } | |
854 | |
855 GLOBAL T_ATI_RSLT queatPlusWS46 (char *cl, UBYTE srcId) | |
856 { | |
857 T_ACI_RETURN ret = AT_FAIL; | |
858 T_ACI_WS46_MOD mode=WS46_MOD_NotPresent; | |
859 | |
860 TRACE_FUNCTION("queatPLusWS46()"); | |
861 | |
862 #ifdef FF_ATI_BAT | |
863 { | |
864 T_BAT_cmd_send cmd; | |
865 T_BAT_no_parameter dummy; | |
866 | |
867 cmd.ctrl_params = BAT_CMD_QUE_PLUS_WS46; | |
868 dummy.bat_dummy = 0xFF; | |
869 cmd.params.ptr_que_plus_ws46 = &dummy; | |
870 bat_send(ati_bat_get_client(srcId), &cmd); | |
871 return(ATI_EXCT); | |
872 } | |
873 #else /* no FF_ATI_BAT */ | |
874 | |
875 ret = qAT_PlusWS46((T_ACI_CMD_SRC)srcId,&mode); | |
876 | |
877 if (ret EQ AT_CMPL) | |
878 { | |
879 resp_disp(srcId, cl,"e",&mode); | |
880 return ATI_CMPL; | |
881 } | |
882 else if (ret EQ AT_FAIL) | |
883 { | |
884 cmdCmeError(CME_ERR_OpNotAllow); | |
885 return ATI_FAIL; | |
886 } | |
887 return (map_aci_2_ati_rslt(ret)); | |
888 | |
889 #endif /* no FF_ATI_BAT */ | |
890 } | |
891 #endif /* TI_PS_FF_WS46 */ | |
892 /* | |
893 +--------------------------------------------------------------------+ | |
894 | PROJECT : GSM-F&D (8411) MODULE : | | |
895 | STATE : code ROUTINE : setatPercentCHPL | | |
896 +--------------------------------------------------------------------+ | |
897 | |
898 PURPOSE : show list of all available entries in the SIM field EF_HPLMNwAcT. | |
899 | |
900 Command Possible Response | |
901 %CHPL=oprFrmt %CHPL: <opr> | |
902 %CHPL=? %CHPL: (list of supported <oprFrmt>s) | |
903 | |
904 <oprFrmt>: | |
905 0 long format alphanumeric <opr> | |
906 1 short format alphanumeric <opr> | |
907 2 numeric <opr> | |
908 | |
909 <opr>: string type; <oprFrmt> indicates if the format is | |
910 alphanumeric or numeric. | |
911 Long alphanumeric can be up to 16 characters. | |
912 Short alphanumeric can be up to 8 characters. | |
913 | |
914 Numeric format is the GSM LAI number, which consists of: | |
915 3 BCD country code. | |
916 2 BCD network code. | |
917 | |
918 The returned <opr> string shall not be in BCD format, but | |
919 in IRA characters converted from BCD. Hence the number | |
920 will have the structure (CC digit 3)(CC digit 2)(CC digit 1) | |
921 (NW digit 2)(NW digit 1). | |
922 | |
923 */ | |
924 | |
925 GLOBAL T_ATI_RSLT setatPercentCHPL( char *cl, UBYTE srcId ) | |
926 { | |
927 T_ACI_CHPL_FRMT format = CHPL_FRMT_NotPresent; | |
928 | |
929 #ifndef FF_ATI_BAT | |
930 T_ACI_OPER_NTRY oper; | |
931 #endif | |
932 | |
933 T_ACI_RETURN ret = AT_FAIL; | |
934 | |
935 TRACE_FUNCTION( "setatPercentCHPL()" ); | |
936 | |
937 if (CFUNfun NEQ CFUN_FUN_Full) | |
938 { | |
939 TRACE_EVENT_P1("+COPS error: cannot proceed Mobile has no Full CFUN: %d", CFUNfun); | |
940 cmdCmeError(CME_ERR_OpNotAllow); | |
941 return ATI_FAIL; | |
942 } | |
943 | |
944 /* parse mode */ | |
945 cl = parse (cl, "d", &format); | |
946 if ((!cl) OR (format > CHPL_FRMT_Numeric) OR (format < CHPL_FRMT_NotPresent)) | |
947 { | |
948 cmdCmeError (CME_ERR_OpNotAllow); | |
949 return (ATI_FAIL); | |
950 } | |
951 | |
952 #ifdef FF_ATI_BAT | |
953 | |
954 { | |
955 T_BAT_cmd_send cmd; | |
956 T_BAT_cmd_set_percent_chpl chpl; | |
957 | |
958 cmd.ctrl_params = BAT_CMD_SET_PERCENT_CHPL; | |
959 cmd.params.ptr_set_percent_chpl=&chpl; | |
960 | |
961 /* | |
962 * This relies on T_ACI_CHPL_FRMT and T_BAT_percent_chpl_oprfrmt being | |
963 * identical. | |
964 */ | |
965 chpl.oprfrmt=(T_BAT_percent_chpl_oprfrmt)format; | |
966 | |
967 bat_send(ati_bat_get_client(srcId), &cmd); | |
968 return(ATI_EXCT); | |
969 } | |
970 | |
971 #else /* no FF_ATI_BAT */ | |
972 | |
973 ret = sAT_PercentCHPL ((T_ACI_CMD_SRC)srcId, &oper); | |
974 if (ret NEQ AT_CMPL) | |
975 { | |
976 cmdCmeError(CME_ERR_Unknown); | |
977 return (ATI_FAIL); | |
978 } | |
979 | |
980 switch (format) | |
981 { | |
982 case CHPL_FRMT_Long : | |
983 sprintf(g_sa, "%s: %s", "%CHPL", oper.longName); | |
984 break; | |
985 | |
986 case CHPL_FRMT_Short : | |
987 sprintf(g_sa, "%s: %s", "%CHPL", oper.shrtName); | |
988 break; | |
989 | |
990 case CHPL_FRMT_Numeric : | |
991 if ((oper.mnc & 0x00F) EQ 0xF) | |
992 /*lint -e{702} */ | |
993 sprintf(g_sa, "%s: %03x,%02x", "%CHPL", oper.mcc, oper.mnc >> 4); | |
994 else | |
995 sprintf(g_sa, "%s: %03x,%03x", "%CHPL", oper.mcc, oper.mnc); | |
996 break; | |
997 | |
998 default : | |
999 cmdCmeError(CME_ERR_Unknown); | |
1000 return (ATI_FAIL); | |
1001 } | |
1002 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1003 | |
1004 return(ATI_CMPL); | |
1005 | |
1006 #endif /* no FF_ATI_BAT */ | |
1007 } | |
1008 | |
1009 /* | |
1010 +--------------------------------------------------------------------+ | |
1011 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1012 | STATE : code ROUTINE : setatPlusCTZR | | |
1013 +--------------------------------------------------------------------+ | |
1014 | |
1015 PURPOSE : %CTZR command (Timezone Mode) | |
1016 */ | |
1017 GLOBAL T_ATI_RSLT setatPlusCTZR (char *cl, UBYTE srcId) | |
1018 { | |
1019 T_ACI_CTZR_MODE mode = CTZR_MODE_OFF; /* CTZR */ | |
1020 T_ACI_RETURN ret = AT_FAIL; | |
1021 | |
1022 TRACE_FUNCTION( "setatPlusCTZR()" ); | |
1023 | |
1024 /* parse mode */ | |
1025 cl = parse (cl, "d", &mode); | |
1026 if ((!cl) OR (mode > CTZR_MODE_ON) OR (mode < CTZR_MODE_OFF))/*lint !e685 (Warning -- 685: Relational operator '>' always evaluates to 'false ) */ | |
1027 { | |
1028 cmdCmeError (CME_ERR_OpNotAllow); | |
1029 return (ATI_FAIL); | |
1030 } | |
1031 | |
1032 ret = sAT_PlusCTZR ((T_ACI_CMD_SRC)srcId, mode); | |
1033 | |
1034 switch (ret) | |
1035 { | |
1036 case (AT_CMPL): /*operation completed*/ | |
1037 break; | |
1038 | |
1039 default: | |
1040 cmdCmeError(CME_ERR_Unknown); /*Command failed*/ | |
1041 break; | |
1042 } | |
1043 return (map_aci_2_ati_rslt(ret)); | |
1044 | |
1045 } | |
1046 | |
1047 /* | |
1048 +--------------------------------------------------------------------+ | |
1049 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1050 | STATE : code ROUTINE : queatPlusCTZR | | |
1051 +--------------------------------------------------------------------+ | |
1052 | |
1053 PURPOSE : %CTZR command (Timezone Mode) | |
1054 */ | |
1055 GLOBAL T_ATI_RSLT queatPlusCTZR (char *cl, UBYTE srcId) | |
1056 { | |
1057 T_ACI_CTZR_MODE mode; | |
1058 T_ACI_RETURN ret = AT_FAIL; | |
1059 | |
1060 TRACE_FUNCTION("queatPlusCTZR()"); | |
1061 | |
1062 ret = qAT_PlusCTZR((T_ACI_CMD_SRC)srcId, &mode); | |
1063 if (ret NEQ AT_CMPL) | |
1064 { | |
1065 cmdCmeError(CME_ERR_Unknown); | |
1066 return (ATI_FAIL); | |
1067 } | |
1068 | |
1069 sprintf(g_sa,"+CTZR: %d", mode); | |
1070 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1071 | |
1072 return ATI_CMPL; | |
1073 } | |
1074 | |
1075 /* | |
1076 +--------------------------------------------------------------------+ | |
1077 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1078 | STATE : code ROUTINE : setatPlusCTZU | | |
1079 +--------------------------------------------------------------------+ | |
1080 | |
1081 PURPOSE : +CTZU command (Timezone Update) | |
1082 */ | |
1083 GLOBAL T_ATI_RSLT setatPlusCTZU (char *cl, UBYTE srcId) | |
1084 { | |
1085 T_ACI_CTZU_MODE mode = CTZU_MODE_OFF; /* CTZU */ | |
1086 T_ACI_RETURN ret = AT_FAIL; | |
1087 | |
1088 TRACE_FUNCTION( "setatPlusCTZU()" ); | |
1089 | |
1090 /* parse mode */ | |
1091 cl = parse (cl, "d", &mode); | |
1092 if ((!cl) OR (mode > CTZU_MODE_ON) OR (mode < CTZU_MODE_OFF))/*lint !e685 (Warning -- 685: Relational operator '>' always evaluates to 'false ) */ | |
1093 { | |
1094 cmdCmeError (CME_ERR_OpNotAllow); | |
1095 return (ATI_FAIL); | |
1096 } | |
1097 | |
1098 #ifdef FF_ATI_BAT | |
1099 | |
1100 { | |
1101 T_BAT_cmd_send cmd; | |
1102 T_BAT_cmd_set_plus_ctzu ctzu; | |
1103 | |
1104 cmd.ctrl_params = BAT_CMD_SET_PLUS_CTZU; | |
1105 cmd.params.ptr_set_plus_ctzu=&ctzu; | |
1106 | |
1107 /* | |
1108 * This relies on T_ACI_CTZU_MODE and T_BAT_plus_ctzu_onoff being | |
1109 * identical. | |
1110 */ | |
1111 ctzu.onoff=(T_BAT_plus_ctzu_onoff)mode; | |
1112 | |
1113 bat_send(ati_bat_get_client(srcId), &cmd); | |
1114 return(ATI_EXCT); | |
1115 } | |
1116 | |
1117 #else /* no FF_ATI_BAT */ | |
1118 | |
1119 ret = sAT_PlusCTZU ((T_ACI_CMD_SRC)srcId, mode); | |
1120 | |
1121 switch (ret) | |
1122 { | |
1123 case (AT_CMPL): /*operation completed*/ | |
1124 break; | |
1125 | |
1126 default: | |
1127 cmdCmeError(CME_ERR_Unknown); /*Command failed*/ | |
1128 break; | |
1129 } | |
1130 return (map_aci_2_ati_rslt(ret)); | |
1131 | |
1132 #endif /* no FF_ATI_BAT */ | |
1133 } | |
1134 | |
1135 | |
1136 /* | |
1137 +--------------------------------------------------------------------+ | |
1138 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1139 | STATE : code ROUTINE : setatPercentCTZV | | |
1140 +--------------------------------------------------------------------+ | |
1141 | |
1142 PURPOSE : %CTZV command (time and date report) | |
1143 */ | |
1144 GLOBAL T_ATI_RSLT setatPercentCTZV (char *cl, UBYTE srcId) | |
1145 { | |
1146 T_ACI_PCTZV_MODE mode = PCTZV_MODE_OFF; /* %CTZV */ | |
1147 T_ACI_RETURN ret = AT_FAIL; | |
1148 | |
1149 TRACE_FUNCTION( "setatPercentCTZV()" ); | |
1150 | |
1151 /* parse mode */ | |
1152 cl = parse (cl, "d", &mode); | |
1153 if ((!cl) OR (mode > PCTZV_MODE_ON) OR (mode < PCTZV_MODE_OFF))/*lint !e685 (Warning -- 685: Relational operator '>' always evaluates to 'false ) */ | |
1154 { | |
1155 cmdCmeError (CME_ERR_OpNotAllow); | |
1156 return (ATI_FAIL); | |
1157 } | |
1158 | |
1159 ret = sAT_PercentCTZV ((T_ACI_CMD_SRC)srcId, mode); | |
1160 | |
1161 switch (ret) | |
1162 { | |
1163 case (AT_CMPL): /*operation completed*/ | |
1164 break; | |
1165 | |
1166 default: | |
1167 cmdCmeError(CME_ERR_Unknown); /*Command failed*/ | |
1168 break; | |
1169 } | |
1170 return (map_aci_2_ati_rslt(ret)); | |
1171 | |
1172 } | |
1173 | |
1174 | |
1175 | |
1176 /* | |
1177 +--------------------------------------------------------------------+ | |
1178 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1179 | STATE : code ROUTINE : setatPercentCNIV | | |
1180 +--------------------------------------------------------------------+ | |
1181 | |
1182 PURPOSE : %CNIV command (network identity report) | |
1183 */ | |
1184 GLOBAL T_ATI_RSLT setatPercentCNIV (char *cl, UBYTE srcId) | |
1185 { | |
1186 T_ACI_CNIV_MODE mode = CNIV_MODE_OFF; /* CNIV */ | |
1187 T_ACI_RETURN ret = AT_FAIL; | |
1188 | |
1189 TRACE_FUNCTION( "setatPercentCNIV()" ); | |
1190 | |
1191 /* parse mode */ | |
1192 cl = parse (cl, "d", &mode); | |
1193 if ((!cl) OR (mode > CNIV_MODE_ON) OR (mode < CNIV_MODE_OFF))/*lint !e685 (Warning -- 685: Relational operator '>' always evaluates to 'false ) */ | |
1194 { | |
1195 cmdCmeError (CME_ERR_OpNotAllow); | |
1196 return (ATI_FAIL); | |
1197 } | |
1198 | |
1199 #ifdef FF_ATI_BAT | |
1200 { | |
1201 T_BAT_cmd_send cmd; | |
1202 T_BAT_cmd_set_percent_cniv my_bat_set_percent_cniv; | |
1203 | |
1204 memset(&my_bat_set_percent_cniv, 0 , sizeof(my_bat_set_percent_cniv)); | |
1205 cmd.ctrl_params = BAT_CMD_SET_PERCENT_CNIV; | |
1206 cmd.params.ptr_set_percent_cniv = &my_bat_set_percent_cniv; | |
1207 | |
1208 my_bat_set_percent_cniv.mode= (T_BAT_VAL_percent_cniv_mode)mode; | |
1209 | |
1210 bat_send(ati_bat_get_client(srcId), &cmd); | |
1211 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
1212 } | |
1213 #else | |
1214 { | |
1215 ret = sAT_PercentCNIV ((T_ACI_CMD_SRC)srcId, mode); | |
1216 | |
1217 switch (ret) | |
1218 { | |
1219 case (AT_CMPL): /*operation completed*/ | |
1220 break; | |
1221 | |
1222 default: | |
1223 cmdCmeError(CME_ERR_Unknown); /*Command failed*/ | |
1224 break; | |
1225 } | |
1226 return (map_aci_2_ati_rslt(ret)); | |
1227 } | |
1228 #endif /* FF_ATI_BAT */ | |
1229 } | |
1230 | |
1231 /* | |
1232 +--------------------------------------------------------------------+ | |
1233 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1234 | STATE : code ROUTINE : queatPlusCTZU | | |
1235 +--------------------------------------------------------------------+ | |
1236 | |
1237 PURPOSE : +CTZU query command (Timezone update) | |
1238 */ | |
1239 GLOBAL T_ATI_RSLT queatPlusCTZU (char *cl, UBYTE srcId) | |
1240 { | |
1241 #ifndef FF_ATI_BAT | |
1242 T_ACI_CTZU_MODE mode; | |
1243 T_ACI_RETURN ret = AT_FAIL; | |
1244 #endif | |
1245 | |
1246 TRACE_FUNCTION("queatPlusCTZU()"); | |
1247 | |
1248 #ifdef FF_ATI_BAT | |
1249 { | |
1250 T_BAT_cmd_send cmd; | |
1251 T_BAT_no_parameter dummy; | |
1252 | |
1253 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CTZU; | |
1254 dummy.bat_dummy = 0xFF; | |
1255 cmd.params.ptr_que_plus_ctzu = &dummy; | |
1256 bat_send(ati_bat_get_client(srcId), &cmd); | |
1257 return(ATI_EXCT); | |
1258 } | |
1259 #else /* no FF_ATI_BAT */ | |
1260 | |
1261 ret = qAT_PlusCTZU((T_ACI_CMD_SRC)srcId, &mode); | |
1262 if (ret NEQ AT_CMPL) | |
1263 { | |
1264 cmdCmeError(CME_ERR_Unknown); | |
1265 return (ATI_FAIL); | |
1266 } | |
1267 | |
1268 sprintf(g_sa,"+CTZU: %d", mode); | |
1269 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1270 | |
1271 return ATI_CMPL; | |
1272 | |
1273 #endif /* no FF_ATI_BAT */ | |
1274 } | |
1275 | |
1276 | |
1277 | |
1278 /* | |
1279 +--------------------------------------------------------------------+ | |
1280 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1281 | STATE : code ROUTINE : queatPercentCTZV | | |
1282 +--------------------------------------------------------------------+ | |
1283 | |
1284 PURPOSE : %CTZV command (time and date report) | |
1285 */ | |
1286 GLOBAL T_ATI_RSLT queatPercentCTZV (char *cl, UBYTE srcId) | |
1287 { | |
1288 T_ACI_PCTZV_MODE mode; | |
1289 T_ACI_RETURN ret = AT_FAIL; | |
1290 | |
1291 TRACE_FUNCTION("queatPercentCTZV()"); | |
1292 | |
1293 ret = qAT_PercentCTZV((T_ACI_CMD_SRC)srcId, &mode); | |
1294 if (ret NEQ AT_CMPL) | |
1295 { | |
1296 cmdCmeError(CME_ERR_Unknown); | |
1297 return (ATI_FAIL); | |
1298 } | |
1299 | |
1300 sprintf(g_sa,"%s: %d","%CTZV", mode); | |
1301 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1302 | |
1303 return ATI_CMPL; | |
1304 } | |
1305 | |
1306 | |
1307 /* | |
1308 +--------------------------------------------------------------------+ | |
1309 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1310 | STATE : code ROUTINE : queatPercentCNIV | | |
1311 +--------------------------------------------------------------------+ | |
1312 | |
1313 PURPOSE : %CNIV command (time and date report) | |
1314 */ | |
1315 GLOBAL T_ATI_RSLT queatPercentCNIV (char *cl, UBYTE srcId) | |
1316 { | |
1317 | |
1318 TRACE_FUNCTION("queatPercentCNIV()"); | |
1319 | |
1320 #ifdef FF_ATI_BAT | |
1321 { | |
1322 T_BAT_cmd_send cmd; | |
1323 T_BAT_no_parameter dummy; | |
1324 | |
1325 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_CNIV; | |
1326 dummy.bat_dummy = 0xFF; | |
1327 cmd.params.ptr_que_percent_cniv= &dummy; | |
1328 | |
1329 bat_send(ati_bat_get_client(srcId), &cmd); | |
1330 | |
1331 return(ATI_EXCT); | |
1332 } | |
1333 #else | |
1334 { | |
1335 T_ACI_CNIV_MODE mode; | |
1336 T_ACI_RETURN ret = AT_FAIL; | |
1337 | |
1338 ret = qAT_PercentCNIV((T_ACI_CMD_SRC)srcId, &mode); | |
1339 if (ret NEQ AT_CMPL) | |
1340 { | |
1341 cmdCmeError(CME_ERR_Unknown); | |
1342 return (ATI_FAIL); | |
1343 } | |
1344 sprintf(g_sa,"%s: %d","%CNIV", mode); | |
1345 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1346 | |
1347 return ATI_CMPL; | |
1348 } | |
1349 #endif /*FF_ATI_BAT*/ | |
1350 } | |
1351 | |
1352 /* | |
1353 +--------------------------------------------------------------------+ | |
1354 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1355 | STATE : code ROUTINE : setatPercentTREG | | |
1356 +--------------------------------------------------------------------+ | |
1357 | |
1358 PURPOSE : %CWUP command (force power campaign) | |
1359 */ | |
1360 | |
1361 GLOBAL T_ATI_RSLT setatPercentCWUP (char *cl, UBYTE srcId) | |
1362 { | |
1363 T_ACI_RETURN ret = AT_FAIL; | |
1364 T_ACI_CWUP_TYPE type; | |
1365 | |
1366 TRACE_FUNCTION( "setatPercentCWUP()" ); | |
1367 | |
1368 /* parse mode */ | |
1369 cl = parse (cl, "d", &type); | |
1370 if ((!cl) OR (type NEQ CWUP_TYPE_RR)) | |
1371 { | |
1372 cmdCmeError (CME_ERR_OpNotAllow); | |
1373 return (ATI_FAIL); | |
1374 } | |
1375 | |
1376 #ifdef FF_ATI_BAT | |
1377 | |
1378 { | |
1379 T_BAT_cmd_send cmd; | |
1380 T_BAT_cmd_set_percent_cwup cwup; | |
1381 | |
1382 cmd.ctrl_params = BAT_CMD_SET_PERCENT_CWUP; | |
1383 cmd.params.ptr_set_percent_cwup=&cwup; | |
1384 | |
1385 /* | |
1386 * This relies on T_ACI_CWUP_TYPE and T_BAT_percent_cwup_type being | |
1387 * identical. | |
1388 */ | |
1389 cwup.type=(T_BAT_percent_cwup_type)type; | |
1390 | |
1391 bat_send(ati_bat_get_client(srcId), &cmd); | |
1392 return(ATI_EXCT); | |
1393 } | |
1394 | |
1395 #else /* no FF_ATI_BAT */ | |
1396 | |
1397 ret = sAT_PercentCWUP ((T_ACI_CMD_SRC)srcId, type); | |
1398 | |
1399 switch (ret) | |
1400 { | |
1401 case (AT_CMPL): /*operation completed*/ | |
1402 break; | |
1403 | |
1404 default: | |
1405 cmdCmeError(CME_ERR_Unknown); /*Command failed*/ | |
1406 break; | |
1407 } | |
1408 return (map_aci_2_ati_rslt(ret)); | |
1409 | |
1410 #endif /* no FF_ATI_BAT */ | |
1411 } | |
1412 | |
1413 /* | |
1414 +--------------------------------------------------------------------+ | |
1415 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1416 | STATE : code ROUTINE : atPlusCIND | | |
1417 +--------------------------------------------------------------------+ | |
1418 | |
1419 PURPOSE : +CIND command | |
1420 (configures the signal strength and SMS full indication) | |
1421 */ | |
1422 GLOBAL T_ATI_RSLT setatPlusCIND (char *cl, UBYTE srcId) | |
1423 { | |
1424 T_ACI_RETURN tRet = AT_FAIL; | |
1425 T_ACI_MM_CIND_VAL_TYPE sCindSettings; | |
1426 | |
1427 TRACE_FUNCTION("setatPLusCIND()"); | |
1428 | |
1429 if (!cl) | |
1430 { | |
1431 cmdCmeError(CME_ERR_OpNotAllow); | |
1432 return ATI_FAIL; | |
1433 } | |
1434 | |
1435 sCindSettings.sCindSignalParam = CIND_SIGNAL_INDICATOR_LVL0; | |
1436 sCindSettings.sCindSmsFullParam = CIND_SMSFULL_INDICATOR_MEMAVAIL; | |
1437 | |
1438 cl = parse(cl,"dd", &sCindSettings.sCindSignalParam, | |
1439 &sCindSettings.sCindSmsFullParam); | |
1440 | |
1441 if ((sCindSettings.sCindSignalParam < CIND_SIGNAL_INDICATOR_LVL0 OR | |
1442 sCindSettings.sCindSignalParam > CIND_SIGNAL_INDICATOR_LVL5) OR | |
1443 (sCindSettings.sCindSmsFullParam < CIND_SMSFULL_INDICATOR_MEMAVAIL OR | |
1444 sCindSettings.sCindSmsFullParam > CIND_SMSFULL_INDICATOR_MEMFULL)) | |
1445 { | |
1446 cmdCmeError(CME_ERR_OpNotAllow); | |
1447 return ATI_FAIL; | |
1448 } | |
1449 | |
1450 #ifdef FF_ATI_BAT | |
1451 { | |
1452 T_BAT_cmd_send cmd; | |
1453 T_BAT_cmd_set_plus_cind cind; | |
1454 | |
1455 /* | |
1456 * Without this we will lose track of the source ID by the time the | |
1457 * response arrives. | |
1458 */ | |
1459 srcId_cb=srcId; | |
1460 | |
1461 cmd.ctrl_params = BAT_CMD_SET_PLUS_CIND; | |
1462 cmd.params.ptr_set_plus_cind=&cind; | |
1463 | |
1464 /* | |
1465 * This relies on T_ACI_CIND_SIGNAL_TYPE being identical to | |
1466 * T_BAT_plus_cind_signal_ctrl and T_ACI_CIND_SMSFULL_TYPE being | |
1467 * identical to T_BAT_plus_cind_smsfull_ctrl. | |
1468 */ | |
1469 cind.signal_ctrl=(T_BAT_plus_cind_signal_ctrl)sCindSettings.sCindSignalParam; | |
1470 cind.smsfull_ctrl=(T_BAT_plus_cind_smsfull_ctrl)sCindSettings.sCindSmsFullParam; | |
1471 | |
1472 bat_send(ati_bat_get_client(srcId), &cmd); | |
1473 return(ATI_EXCT); | |
1474 } | |
1475 #else /* no FF_ATI_BAT */ | |
1476 | |
1477 tRet = sAT_PlusCIND( (T_ACI_CMD_SRC)srcId, sCindSettings.sCindSignalParam, | |
1478 sCindSettings.sCindSmsFullParam ); | |
1479 | |
1480 if (tRet EQ AT_FAIL) | |
1481 { | |
1482 cmdCmeError(CME_ERR_OpNotAllow); | |
1483 return ATI_FAIL; | |
1484 } | |
1485 return ATI_CMPL; | |
1486 | |
1487 #endif /* no FF_ATI_BAT */ | |
1488 } | |
1489 | |
1490 /* | |
1491 +--------------------------------------------------------------------+ | |
1492 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1493 | STATE : code ROUTINE : queatPlusCIND | | |
1494 +--------------------------------------------------------------------+ | |
1495 | |
1496 PURPOSE : +CIND query command | |
1497 (query the configured unsolicited signal strength | |
1498 and SMS full indication settings) | |
1499 */ | |
1500 GLOBAL T_ATI_RSLT queatPlusCIND ( char *cl, UBYTE srcId ) | |
1501 { | |
1502 #ifndef FF_ATI_BAT | |
1503 T_ACI_RETURN sRet = AT_FAIL; | |
1504 T_ACI_MM_CIND_VAL_TYPE sCindSettings; | |
1505 #endif | |
1506 | |
1507 TRACE_FUNCTION("queatPlusCIND()"); | |
1508 | |
1509 #ifdef FF_ATI_BAT | |
1510 { | |
1511 T_BAT_cmd_send cmd; | |
1512 T_BAT_no_parameter dummy; | |
1513 | |
1514 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CIND; | |
1515 dummy.bat_dummy = 0xFF; | |
1516 cmd.params.ptr_que_plus_cind = &dummy; | |
1517 bat_send(ati_bat_get_client(srcId), &cmd); | |
1518 return(ATI_EXCT); | |
1519 } | |
1520 #else /* no FF_ATI_BAT */ | |
1521 | |
1522 sRet = qAT_PlusCIND( (T_ACI_CMD_SRC)srcId, &sCindSettings.sCindSignalParam, | |
1523 &sCindSettings.sCindSmsFullParam ); | |
1524 | |
1525 if ( sCindSettings.sCindSignalParam EQ CIND_SIGNAL_INDICATOR_INVALID ) { sCindSettings.sCindSignalParam = CIND_SIGNAL_INDICATOR_LVL0; } | |
1526 if ( sCindSettings.sCindSmsFullParam EQ CIND_SMSFULL_INDICATOR_INVALID ) { sCindSettings.sCindSmsFullParam = CIND_SMSFULL_INDICATOR_MEMAVAIL; } | |
1527 | |
1528 if (sRet EQ AT_CMPL) | |
1529 { | |
1530 resp_disp( srcId, cl,"ee", &sCindSettings.sCindSignalParam, | |
1531 &sCindSettings.sCindSmsFullParam ); | |
1532 return ATI_CMPL; | |
1533 } | |
1534 else | |
1535 { /* error case */ | |
1536 cmdCmeError(CME_ERR_OpNotAllow); | |
1537 return ATI_FAIL; | |
1538 } | |
1539 | |
1540 #endif /* no FF_ATI_BAT */ | |
1541 } | |
1542 | |
1543 /* | |
1544 +--------------------------------------------------------------------+ | |
1545 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1546 | STATE : code ROUTINE : atPlusCMER | | |
1547 +--------------------------------------------------------------------+ | |
1548 | |
1549 PURPOSE : +CMER command | |
1550 (configures the kind of indication handling toward terminal) | |
1551 */ | |
1552 GLOBAL T_ATI_RSLT setatPlusCMER ( char *cl, UBYTE srcId ) | |
1553 { | |
1554 /* UINT uiBufferCounter; */ | |
1555 T_ACI_RETURN tRet = AT_FAIL; | |
1556 T_ACI_MM_CMER_VAL_TYPE sCmerSettings; | |
1557 T_ACI_MM_CMER_VAL_TYPE sOldCmerSettings; | |
1558 T_ACI_MM_CMER_VAL_TYPE sEnteredCmerSettings; | |
1559 UINT uiDummy1 = 0u; | |
1560 UINT uiDummy2 = 0u; | |
1561 | |
1562 TRACE_FUNCTION("setatPLusCMER()"); | |
1563 | |
1564 if (!cl) | |
1565 { | |
1566 cmdCmeError(CME_ERR_OpNotAllow); | |
1567 return ATI_FAIL; | |
1568 } | |
1569 | |
1570 sCmerSettings.sCmerModeParam = CMER_MODE_INVALID; | |
1571 sCmerSettings.sCmerIndParam = CMER_INDICATOR_INVALID; | |
1572 sCmerSettings.sCmerBfrParam = CMER_BFR_INVALID; | |
1573 | |
1574 cl = parse(cl,"ddddd", &sCmerSettings.sCmerModeParam, | |
1575 &uiDummy1, | |
1576 &uiDummy2, | |
1577 &sCmerSettings.sCmerIndParam, | |
1578 &sCmerSettings.sCmerBfrParam ); | |
1579 | |
1580 if ((sCmerSettings.sCmerModeParam < CMER_MODE_INVALID OR | |
1581 sCmerSettings.sCmerModeParam > CMER_MODE_2) OR | |
1582 (sCmerSettings.sCmerIndParam < CMER_INDICATOR_INVALID OR | |
1583 sCmerSettings.sCmerIndParam > CMER_INDICATOR_2) OR | |
1584 (sCmerSettings.sCmerBfrParam < CMER_BFR_INVALID OR | |
1585 sCmerSettings.sCmerBfrParam > CMER_BFR_1) OR | |
1586 (uiDummy1 NEQ 0u) OR ((uiDummy2 NEQ 0u))) | |
1587 { | |
1588 cmdCmeError(CME_ERR_OpNotAllow); | |
1589 return ATI_FAIL; | |
1590 } | |
1591 | |
1592 cmhMM_GetCmerSettings( (T_ACI_CMD_SRC)srcId, &sOldCmerSettings ); | |
1593 | |
1594 sEnteredCmerSettings.sCmerModeParam = sCmerSettings.sCmerModeParam; | |
1595 | |
1596 #ifdef FF_ATI_BAT | |
1597 { | |
1598 T_BAT_cmd_send cmd; | |
1599 T_BAT_cmd_set_plus_cmer cmer; | |
1600 | |
1601 /* | |
1602 * Without this we will lose track of the source ID by the time the | |
1603 * response arrives. | |
1604 */ | |
1605 srcId_cb=srcId; | |
1606 | |
1607 cmd.ctrl_params = BAT_CMD_SET_PLUS_CMER; | |
1608 cmd.params.ptr_set_plus_cmer=&cmer; | |
1609 | |
1610 cmer.ind_option=BAT_CMER_IND_OPTION_NOT_PRESENT; | |
1611 | |
1612 bat_send(ati_bat_get_client(srcId), &cmd); | |
1613 return(ATI_EXCT); | |
1614 } | |
1615 #else /* no FF_ATI_BAT */ | |
1616 | |
1617 tRet = sAT_PlusCMER((T_ACI_CMD_SRC)srcId, sCmerSettings.sCmerModeParam, | |
1618 sCmerSettings.sCmerIndParam, | |
1619 sCmerSettings.sCmerBfrParam ); | |
1620 if (tRet EQ AT_FAIL) | |
1621 { | |
1622 cmdCmeError(CME_ERR_OpNotAllow); | |
1623 return ATI_FAIL; | |
1624 } | |
1625 | |
1626 if ( sCmerSettings.sCmerModeParam EQ CMER_MODE_INVALID ) { sCmerSettings.sCmerModeParam = sOldCmerSettings.sCmerModeParam; } | |
1627 if ( sCmerSettings.sCmerIndParam EQ CMER_INDICATOR_INVALID ) { sCmerSettings.sCmerIndParam = sOldCmerSettings.sCmerIndParam; } | |
1628 if ( sCmerSettings.sCmerBfrParam EQ CMER_BFR_INVALID ) { sCmerSettings.sCmerBfrParam = sOldCmerSettings.sCmerBfrParam; } | |
1629 if ( sCmerSettings.sCmerIndParam EQ CMER_INDICATOR_INVALID ) { sCmerSettings.sCmerIndParam = CMER_INDICATOR_0; } | |
1630 if ( sCmerSettings.sCmerBfrParam EQ CMER_BFR_INVALID ) { sCmerSettings.sCmerBfrParam = CMER_BFR_0; } | |
1631 | |
1632 switch( sCmerSettings.sCmerModeParam ) | |
1633 { | |
1634 case CMER_MODE_INVALID : | |
1635 case CMER_MODE_0 : | |
1636 { /* always buffer --> do nothing */ | |
1637 break; | |
1638 } | |
1639 case CMER_MODE_1 : | |
1640 case CMER_MODE_2 : | |
1641 { /* flush and/or clear buffer */ | |
1642 if ( (sEnteredCmerSettings.sCmerModeParam EQ CMER_MODE_1) OR | |
1643 (sEnteredCmerSettings.sCmerModeParam EQ CMER_MODE_2) ) | |
1644 { | |
1645 if ( sCmerSettings.sCmerBfrParam EQ CMER_BFR_0 ) | |
1646 { | |
1647 cmd_clearCievBuf( srcId ); | |
1648 } | |
1649 else | |
1650 { /* BFR == '2' */ | |
1651 cmd_flushCievBuf( srcId ); | |
1652 } | |
1653 | |
1654 } | |
1655 break; | |
1656 } | |
1657 default : | |
1658 { /* error case */ | |
1659 cmdCmeError(CME_ERR_OpNotAllow); | |
1660 return ATI_FAIL; | |
1661 } | |
1662 } | |
1663 return ATI_CMPL; | |
1664 | |
1665 #endif /* no FF_ATI_BAT */ | |
1666 } | |
1667 | |
1668 /* | |
1669 +--------------------------------------------------------------------+ | |
1670 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1671 | STATE : code ROUTINE : queatPlusCMER | | |
1672 +--------------------------------------------------------------------+ | |
1673 | |
1674 PURPOSE : +CMER query command | |
1675 (query the configured indication handling settings | |
1676 toward terminal ) | |
1677 */ | |
1678 GLOBAL T_ATI_RSLT queatPlusCMER ( char *cl, UBYTE srcId ) | |
1679 { | |
1680 #ifndef FF_ATI_BAT | |
1681 T_ACI_RETURN sRet = AT_FAIL; | |
1682 T_ACI_MM_CMER_VAL_TYPE sCmerSettings; | |
1683 UINT uiDummy = 0u; | |
1684 #endif | |
1685 | |
1686 TRACE_FUNCTION("queatPLusCMER()"); | |
1687 | |
1688 #ifdef FF_ATI_BAT | |
1689 { | |
1690 T_BAT_cmd_send cmd; | |
1691 T_BAT_no_parameter dummy; | |
1692 | |
1693 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CMER; | |
1694 dummy.bat_dummy = 0xFF; | |
1695 cmd.params.ptr_que_plus_cmer = &dummy; | |
1696 bat_send(ati_bat_get_client(srcId), &cmd); | |
1697 return(ATI_EXCT); | |
1698 } | |
1699 #else /* no FF_ATI_BAT */ | |
1700 | |
1701 sRet = qAT_PlusCMER( (T_ACI_CMD_SRC)srcId, &sCmerSettings.sCmerModeParam, | |
1702 &sCmerSettings.sCmerIndParam, | |
1703 &sCmerSettings.sCmerBfrParam ); | |
1704 | |
1705 if (sRet NEQ AT_CMPL) | |
1706 { | |
1707 cmdCmeError(CME_ERR_OpNotAllow); | |
1708 return ATI_FAIL; | |
1709 } | |
1710 | |
1711 if ( sCmerSettings.sCmerModeParam EQ CMER_MODE_INVALID ) { sCmerSettings.sCmerModeParam = CMER_MODE_0; }; | |
1712 if ( sCmerSettings.sCmerIndParam EQ CMER_INDICATOR_INVALID ) { sCmerSettings.sCmerIndParam = CMER_INDICATOR_0; }; | |
1713 if ( sCmerSettings.sCmerBfrParam EQ CMER_BFR_INVALID ) { sCmerSettings.sCmerBfrParam = CMER_BFR_0; }; | |
1714 | |
1715 resp_disp( srcId, cl,"eeeee",&sCmerSettings.sCmerModeParam, | |
1716 &uiDummy, | |
1717 &uiDummy, | |
1718 &sCmerSettings.sCmerIndParam, | |
1719 &sCmerSettings.sCmerBfrParam ); | |
1720 return ATI_CMPL; | |
1721 | |
1722 #endif /* no FF_ATI_BAT */ | |
1723 } | |
1724 | |
1725 /* | |
1726 +--------------------------------------------------------------------+ | |
1727 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1728 | STATE : code ROUTINE : cmd_flushCievBuf | | |
1729 +--------------------------------------------------------------------+ | |
1730 | |
1731 PURPOSE : This function flushes the buffer for storing new signal- | |
1732 and/or SMS-full indications while the serial interface is | |
1733 released from data transmission. | |
1734 */ | |
1735 GLOBAL void cmd_flushCievBuf ( UBYTE srcId ) | |
1736 { | |
1737 UINT uiBufferCounter; | |
1738 UINT uiTempLastIndex; | |
1739 T_ACI_MM_CIND_VAL_TYPE sCindValues; | |
1740 T_ACI_MM_CMER_VAL_TYPE sCmerSettings; | |
1741 | |
1742 TRACE_FUNCTION("cmd_flushCievBuf"); | |
1743 | |
1744 /* Signal buffer */ | |
1745 uiTempLastIndex = asCievSignalBuf.uiLastIndex; | |
1746 cmhMM_GetCmerSettings((T_ACI_CMD_SRC)srcId, &sCmerSettings); | |
1747 for( uiBufferCounter=0; uiBufferCounter < uiTempLastIndex; uiBufferCounter++ ) | |
1748 { | |
1749 sCindValues.sCindSignalParam = asCievSignalBuf.asBufferValues[uiBufferCounter]; | |
1750 sCindValues.sCindSmsFullParam = CIND_SMSFULL_INDICATOR_INVALID; | |
1751 rCI_PlusCIEV( sCindValues, sCmerSettings ); | |
1752 asCievSignalBuf.asBufferValues[uiBufferCounter] = CIND_SIGNAL_INDICATOR_INVALID; | |
1753 asCievSignalBuf.uiLastIndex--; | |
1754 } | |
1755 | |
1756 /* SMS Full buffer */ | |
1757 uiTempLastIndex = asCievSmsFullBuf.uiLastIndex; | |
1758 for( uiBufferCounter=0; uiBufferCounter < uiTempLastIndex; uiBufferCounter++ ) | |
1759 { | |
1760 sCindValues.sCindSmsFullParam = asCievSmsFullBuf.asBufferValues[uiBufferCounter]; | |
1761 sCindValues.sCindSignalParam = CIND_SIGNAL_INDICATOR_INVALID; | |
1762 rCI_PlusCIEV( sCindValues, sCmerSettings ); | |
1763 asCievSmsFullBuf.asBufferValues[uiBufferCounter] = CIND_SMSFULL_INDICATOR_INVALID; | |
1764 asCievSmsFullBuf.uiLastIndex--; | |
1765 } | |
1766 } | |
1767 | |
1768 /* | |
1769 +--------------------------------------------------------------------+ | |
1770 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1771 | STATE : code ROUTINE : cmd_clearCievBuf | | |
1772 +--------------------------------------------------------------------+ | |
1773 | |
1774 PURPOSE : This function clear the buffer for storing new signal- | |
1775 and/or SMS-full indications | |
1776 */ | |
1777 GLOBAL void cmd_clearCievBuf ( UBYTE srcId ) | |
1778 { | |
1779 UBYTE tSrc; | |
1780 | |
1781 for( tSrc=0; tSrc < CIEV_BUF_SIZE; tSrc++ ) | |
1782 { | |
1783 asCievSignalBuf.asBufferValues[tSrc] = CIND_SIGNAL_INDICATOR_INVALID; | |
1784 asCievSmsFullBuf.asBufferValues[tSrc] = CIND_SMSFULL_INDICATOR_INVALID; | |
1785 } | |
1786 asCievSignalBuf.uiLastIndex = 0u; | |
1787 asCievSmsFullBuf.uiLastIndex = 0u; | |
1788 } | |
1789 | |
1790 /* | |
1791 +--------------------------------------------------------------------+ | |
1792 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1793 | STATE : code ROUTINE : cmd_PlusCOPN_CB | | |
1794 +--------------------------------------------------------------------+ | |
1795 | |
1796 PURPOSE : Call back function for cmd_PlusCOPN_CB | |
1797 */ | |
1798 | |
1799 GLOBAL void cmd_PlusCOPN_CB ( UBYTE src_id ) | |
1800 { | |
1801 SHORT startIdx; | |
1802 UBYTE curCmd; | |
1803 T_ATI_SRC_PARAMS *src_params; | |
1804 T_COPN_VAR *COPN_Var; | |
1805 BOOL ret; | |
1806 | |
1807 | |
1808 COPN_Var = &mmShrdPrm.COPN_VAR[src_id]; | |
1809 | |
1810 | |
1811 startIdx = COPN_Var->Start_Count; | |
1812 | |
1813 | |
1814 TRACE_FUNCTION("cmd_PlusCOPN_CB()"); | |
1815 | |
1816 ret = cmd_readCOPNBlock(startIdx,src_id); | |
1817 | |
1818 if (ret EQ TRUE) | |
1819 { | |
1820 src_params = find_element (ati_src_list, src_id, search_ati_src_id); | |
1821 curCmd = src_params->curAtCmd; | |
1822 R_AT( RAT_OK, (T_ACI_CMD_SRC)src_id ) | |
1823 ( curCmd ); | |
1824 } | |
1825 } | |
1826 | |
1827 GLOBAL BOOL cmd_readCOPNBlock( SHORT startIdx, UBYTE src_id ) | |
1828 { | |
1829 SHORT lastIdx; | |
1830 UBYTE idx; | |
1831 T_ACI_COPN_LST operLst; | |
1832 T_COPN_VAR *COPN_Var; | |
1833 | |
1834 COPN_Var = &mmShrdPrm.COPN_VAR[src_id]; | |
1835 | |
1836 TRACE_FUNCTION("cmd_readCOPNBlock()"); | |
1837 | |
1838 if( qAT_PlusCOPN((T_ACI_CMD_SRC)src_id, COPN_LID_Cnst, startIdx, | |
1839 &lastIdx, operLst) EQ AT_FAIL ) | |
1840 return TRUE; | |
1841 | |
1842 for( idx=0; idx < MAX_OPER; idx++ ) | |
1843 { | |
1844 if( operLst[idx].numOper[0] EQ 0x0 ) | |
1845 return TRUE; | |
1846 | |
1847 sprintf(g_sa,"+COPN: \"%s\",\"%s\"",operLst[idx].numOper, | |
1848 operLst[idx].alphaOper ); | |
1849 io_sendMessage(src_id, g_sa, ATI_NORMAL_OUTPUT); | |
1850 } | |
1851 startIdx = lastIdx+1; | |
1852 COPN_Var->Start_Count = startIdx; | |
1853 return FALSE; | |
1854 } | |
1855 | |
1856 | |
1857 #endif /* ATI_MM_C */ |