FreeCalypso > hg > freecalypso-citrine
comparison g23m-aci/aci/ati_sim.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: SIM related functions. | |
18 +----------------------------------------------------------------------------- | |
19 */ | |
20 | |
21 #ifndef ATI_SIM_C | |
22 #define ATI_SIM_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_cmh.h" | |
34 #include "ati_cmd.h" | |
35 #include "aci_io.h" | |
36 #include "aci_cmd.h" | |
37 #include "l4_tim.h" | |
38 | |
39 #include "gdi.h" | |
40 #include "audio.h" | |
41 | |
42 #include "aci_mem.h" | |
43 #include "aci_ext_pers.h" | |
44 #include "aci_slock.h" | |
45 #include "aci_prs.h" | |
46 #include "aci_lst.h" | |
47 #include "ati_int.h" | |
48 | |
49 #ifdef FF_ATI_BAT | |
50 | |
51 #include "typedefs.h" | |
52 #include "gdd.h" | |
53 #include "bat.h" | |
54 | |
55 #include "ati_bat.h" | |
56 | |
57 #endif /* FF_ATI_BAT */ | |
58 | |
59 /*==== EXPORT ==================================================*/ | |
60 | |
61 EXTERN CHAR *cmdExtError (T_ACI_EXT_ERR e); | |
62 | |
63 #ifdef TI_PS_FF_AT_P_CMD_SECP | |
64 /* | |
65 +--------------------------------------------------------------------+ | |
66 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
67 | STATE : code ROUTINE : setatPercentSECP | | |
68 +--------------------------------------------------------------------+ | |
69 | |
70 PURPOSE : %SECP command (PIN functionality for MMI Security) | |
71 */ | |
72 | |
73 GLOBAL T_ATI_RSLT setatPercentSECP(CHAR * cl, UBYTE srcId) | |
74 { | |
75 char pinOld [MAX_PWD_LENGTH]={0}; | |
76 char pinNew [MAX_PWD_LENGTH]={0}; | |
77 T_ACI_RETURN ret = AT_FAIL; | |
78 | |
79 TRACE_FUNCTION ("setatPercentSECP()"); | |
80 | |
81 cl = parse(cl, "nn", (LONG)MAX_PWD_LENGTH, pinOld,(LONG)MAX_PWD_LENGTH, pinNew); | |
82 if ( !cl OR (*pinOld EQ '\0' AND *pinNew EQ '\0') ) | |
83 { | |
84 cmdCmeError(CME_ERR_OpNotAllow); | |
85 return ATI_FAIL; | |
86 } | |
87 | |
88 ret = sAT_PercentSECP((T_ACI_CMD_SRC)srcId, pinOld, pinNew); | |
89 | |
90 return (map_aci_2_ati_rslt(ret)); | |
91 } | |
92 #endif /* TI_PS_FF_AT_P_CMD_SECP */ | |
93 | |
94 #ifdef TI_PS_FF_AT_P_CMD_SECS | |
95 /* | |
96 +--------------------------------------------------------------------+ | |
97 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
98 | STATE : code ROUTINE : setatPercentSECS | | |
99 +--------------------------------------------------------------------+ | |
100 | |
101 PURPOSE : %SECS command (This function changes the state of the MMI Security code | |
102 It requires the existing security code as one of the parameters) | |
103 */ | |
104 | |
105 | |
106 GLOBAL T_ATI_RSLT setatPercentSECS (CHAR *cl, UBYTE srcId) | |
107 { | |
108 char code [MAX_PWD_LENGTH]={0}; | |
109 T_ACI_SECS_STA securityState = SECS_STA_NotPresent; | |
110 T_ACI_RETURN ret = AT_FAIL; | |
111 | |
112 | |
113 TRACE_FUNCTION ("setatPercentSECS()"); | |
114 | |
115 /* Get the required state and the Security code from the command parameters*/ | |
116 cl = parse(cl, "dn", &securityState, (LONG)MAX_PWD_LENGTH, code); | |
117 | |
118 if ( !cl OR *code EQ '\0' ) | |
119 { | |
120 cmdCmeError(CME_ERR_OpNotAllow); | |
121 return ATI_FAIL; | |
122 } | |
123 | |
124 ret = sAT_PercentSECS((T_ACI_CMD_SRC)srcId,securityState,code); | |
125 return (map_aci_2_ati_rslt(ret)); | |
126 | |
127 | |
128 } | |
129 | |
130 | |
131 /* | |
132 +--------------------------------------------------------------------+ | |
133 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
134 | STATE : code ROUTINE : qetatPercentSECS | | |
135 +--------------------------------------------------------------------+ | |
136 | |
137 PURPOSE : %SECS? command (It queries the state of the MMI Security code) | |
138 */ | |
139 | |
140 | |
141 GLOBAL T_ATI_RSLT quetatPercentSECS (CHAR *cl, UBYTE srcId) | |
142 { | |
143 T_ACI_SECS_STA securityState = SECS_STA_NotPresent; | |
144 T_ACI_RETURN ret = AT_FAIL; | |
145 | |
146 | |
147 TRACE_FUNCTION ("qetatPercentSECS()"); | |
148 | |
149 /* Get the State value from the Command Handler */ | |
150 ret = qAT_PercentSECS((T_ACI_CMD_SRC)srcId, &securityState); | |
151 | |
152 if (ret EQ AT_CMPL) | |
153 { | |
154 resp_disp(srcId, cl,"e",&securityState); | |
155 return ATI_CMPL; | |
156 } | |
157 else | |
158 { | |
159 cmdCmeError(CME_ERR_Unknown); | |
160 return ATI_FAIL; | |
161 } | |
162 | |
163 | |
164 } | |
165 #endif /* TI_PS_FF_AT_P_CMD_SECS */ | |
166 | |
167 | |
168 GLOBAL CHAR *CPIN_RESULT(T_ACI_CPIN_RSLT code) | |
169 { | |
170 switch (code) | |
171 { | |
172 default: | |
173 case(CPIN_RSLT_NotPresent): return"not present"; | |
174 case(CPIN_RSLT_SimReady): return"READY"; | |
175 case(CPIN_RSLT_SimPinReq): return"SIM PIN"; | |
176 case(CPIN_RSLT_SimPukReq): return"SIM PUK"; | |
177 case(CPIN_RSLT_PhSimPinReq):return"PH-SIM PIN"; | |
178 case(CPIN_RSLT_SimPin2Req): return"SIM PIN2"; | |
179 case(CPIN_RSLT_SimPuk2Req): return"SIM PUK2"; | |
180 /* OVK: Extended list of all possible result according to 07.07 */ | |
181 case(CPIN_RSLT_PhFSimPinReq): return"PH-FSIM PIN"; | |
182 case(CPIN_RSLT_PhFSimPukReq): return"PH-FSIM PUK"; | |
183 case(CPIN_RSLT_PhNetPinReq): return"PH-NET PIN"; | |
184 case(CPIN_RSLT_PhNetPukReq): return"PH_NET PUK"; | |
185 case(CPIN_RSLT_PhNetSubPinReq): return"PH-NETSUB PIN"; | |
186 case(CPIN_RSLT_PhNetSubPukReq): return"PH-NETSUB PUK"; | |
187 case(CPIN_RSLT_PhSPPinReq): return"PH-SP PIN"; | |
188 case(CPIN_RSLT_PhSPPukReq): return"PH-SP PUK"; | |
189 case(CPIN_RSLT_PhCorpPinReq): return"PH-CORP PIN"; | |
190 case(CPIN_RSLT_PhCorpPukReq): return"PH-CORP PUK"; | |
191 | |
192 | |
193 } | |
194 } | |
195 | |
196 /* | |
197 +--------------------------------------------------------------------+ | |
198 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
199 | STATE : code ROUTINE : atPlusCPIN | | |
200 +--------------------------------------------------------------------+ | |
201 | |
202 PURPOSE : +CPIN command (PIN functionality of ME) | |
203 */ | |
204 | |
205 GLOBAL T_ATI_RSLT setatPlusCPIN (char *cl, UBYTE srcId) | |
206 { | |
207 char pinOld [MAX_PWD_LENGTH]={0}; /* ES!! enough for bad guys?*/ | |
208 char pinNew [MAX_PWD_LENGTH]={0}; | |
209 T_ACI_RETURN ret = AT_FAIL; | |
210 UBYTE slockBlocked = 0; /* @GBR: AT_CMPL is interpreted as error per default. This is wrong, if the ME is SIMLOCKed */ | |
211 | |
212 TRACE_FUNCTION ("setatPlusCPIN()"); | |
213 | |
214 cl = parse(cl,"nn",(LONG)MAX_PWD_LENGTH,&pinOld,(LONG)MAX_PWD_LENGTH,&pinNew); | |
215 if ( !cl OR *pinOld EQ '\0' ) | |
216 { | |
217 cmdCmeError(CME_ERR_OpNotAllow); | |
218 return ATI_FAIL; | |
219 } | |
220 #ifdef SIM_PERS | |
221 slockBlocked = AciSLockShrd.blocked; | |
222 #endif | |
223 #ifdef FF_ATI_BAT | |
224 { | |
225 T_BAT_cmd_send cmd; | |
226 T_BAT_cmd_set_plus_cpin my_bat_set_plus_cpin = {0}; | |
227 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
228 | |
229 TRACE_FUNCTION("setatPlusCPIN() calls bat_send() <=== as APPLICATION"); | |
230 | |
231 /* memset(&my_bat_set_plus_cpin, FALSE, sizeof(my_bat_set_plus_cpin)); Already initilaised */ | |
232 cmd.ctrl_params = BAT_CMD_SET_PLUS_CPIN; | |
233 cmd.params.ptr_set_plus_cpin = &my_bat_set_plus_cpin; | |
234 | |
235 /* Set old pin BAT attribs */ | |
236 my_bat_set_plus_cpin.c_pin = strlen(pinOld); | |
237 memcpy(my_bat_set_plus_cpin.pin, pinOld, BAT_MAX_CPIN_PIN_LEN); | |
238 | |
239 /* Set new pin BAT attribs */ | |
240 if(my_bat_set_plus_cpin.c_newpin = strlen(pinNew)) | |
241 { | |
242 my_bat_set_plus_cpin.v_newpin = TRUE; | |
243 memcpy(my_bat_set_plus_cpin.pin, pinNew, BAT_MAX_CPIN_PIN_LEN); | |
244 } | |
245 | |
246 src_params->curAtCmd = AT_CMD_CPIN; | |
247 | |
248 bat_send(ati_bat_get_client(srcId), &cmd); | |
249 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
250 } | |
251 | |
252 #else /* no FF_ATI_BAT */ | |
253 | |
254 TRACE_FUNCTION("setatPlusCPIN()"); | |
255 ret = sAT_PlusCPIN ((T_ACI_CMD_SRC)srcId,pinOld,pinNew); | |
256 | |
257 switch(ret) | |
258 { | |
259 case(AT_EXCT): | |
260 { | |
261 break; | |
262 } | |
263 case(AT_BUSY): | |
264 { | |
265 cmdCmeError(CME_ERR_SimBusy); | |
266 break; | |
267 } | |
268 case(AT_FAIL): | |
269 { | |
270 cmdCmeError(CME_ERR_Unknown); | |
271 break; | |
272 } | |
273 case(AT_CMPL): | |
274 { | |
275 if (!slockBlocked) | |
276 { | |
277 cmdCmeError(CME_ERR_Unknown); | |
278 } | |
279 break; | |
280 } | |
281 } | |
282 return (map_aci_2_ati_rslt(ret)); | |
283 #endif /* FF_ATI_BAT */ | |
284 } | |
285 | |
286 GLOBAL T_ATI_RSLT queatPlusCPIN (char *cl, UBYTE srcId) | |
287 { | |
288 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
289 src_params->curAtCmd = AT_CMD_CPIN; | |
290 | |
291 #ifdef FF_ATI_BAT | |
292 { | |
293 T_BAT_cmd_send cmd; | |
294 T_BAT_no_parameter dummy; | |
295 | |
296 TRACE_FUNCTION("queatPlusCPIN() calls bat_send() <=== as APPLICATION"); | |
297 | |
298 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CPIN; | |
299 dummy.bat_dummy = 0xFF; | |
300 cmd.params.ptr_que_plus_cpin = &dummy; | |
301 bat_send(ati_bat_get_client(srcId), &cmd); | |
302 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
303 } | |
304 #else /* no FF_ATI_BAT */ | |
305 { | |
306 T_ACI_RETURN ret = AT_FAIL; | |
307 T_ACI_CPIN_RSLT code; | |
308 | |
309 TRACE_FUNCTION ("queatPlusCPIN()"); | |
310 | |
311 ret= qAT_PlusCPIN ((T_ACI_CMD_SRC)srcId,&code); /*PIN status is requested*/ | |
312 switch (ret) | |
313 { | |
314 case(AT_CMPL): | |
315 { | |
316 sprintf (g_sa,"+CPIN: %s",CPIN_RESULT(code)); | |
317 io_sendMessage (srcId, g_sa, ATI_NORMAL_OUTPUT); | |
318 break; | |
319 } | |
320 case(AT_EXCT): | |
321 { | |
322 src_params->curAtCmd = AT_CMD_CPIN; | |
323 break; | |
324 } | |
325 default: | |
326 { | |
327 cmdCmeError (CME_ERR_Unknown); | |
328 break; | |
329 } | |
330 } | |
331 return (map_aci_2_ati_rslt(ret)); | |
332 } | |
333 #endif /* no FF_ATI_BAT */ | |
334 } | |
335 | |
336 /* | |
337 +--------------------------------------------------------------------+ | |
338 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
339 | STATE : code ROUTINE : atPlusCPOL | | |
340 +--------------------------------------------------------------------+ | |
341 | |
342 PURPOSE : +CPOL command (preferred operator list) | |
343 */ | |
344 | |
345 GLOBAL T_ATI_RSLT setatPlusCPOL (char *cl, UBYTE srcId) | |
346 { | |
347 T_ACI_CPOL_FRMT format = CPOL_FRMT_NotPresent; | |
348 SHORT index = ACI_NumParmNotPresent; | |
349 char op[20] = {0}; | |
350 T_ACI_RETURN ret = AT_FAIL; | |
351 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
352 | |
353 TRACE_FUNCTION("setatPlusCPOL()"); | |
354 | |
355 cl = parse(cl,"dds",&index,&format,(LONG)20,op); | |
356 if(!cl) | |
357 { | |
358 cmdCmeError(CME_ERR_OpNotAllow); | |
359 return ATI_FAIL; | |
360 } | |
361 | |
362 #ifdef FF_ATI_BAT | |
363 | |
364 { | |
365 T_BAT_cmd_send cmd; | |
366 T_BAT_cmd_set_plus_cpol cpol; | |
367 UBYTE len; | |
368 | |
369 len=strlen(op); | |
370 | |
371 /* | |
372 * If the operator name is too big for the BAT structure, there's | |
373 * nothing we can do. A truncated version would be meaningless, and | |
374 * to omit it would result in an operator being deleted from the | |
375 * list. | |
376 */ | |
377 if (len>BAT_MAX_CPOL_OPER_LEN) | |
378 return(ATI_FAIL); | |
379 | |
380 cmd.ctrl_params = BAT_CMD_SET_PLUS_CPOL; | |
381 cmd.params.ptr_set_plus_cpol=&cpol; | |
382 | |
383 cpol.index=(S16)index; | |
384 | |
385 /* | |
386 * This relies on T_ACI_CPOL_FRMT being identical to | |
387 * T_BAT_plus_cpol_format. | |
388 */ | |
389 cpol.format=(T_BAT_plus_cpol_format)format; | |
390 | |
391 if (len>0) | |
392 { | |
393 memcpy(cpol.oper,op,len); | |
394 cpol.v_oper=TRUE; | |
395 cpol.c_oper=(U8)len; | |
396 } | |
397 else | |
398 { | |
399 cpol.v_oper=FALSE; | |
400 } | |
401 | |
402 bat_send(ati_bat_get_client(srcId), &cmd); | |
403 src_params->curAtCmd=AT_CMD_CPOL; | |
404 return(ATI_EXCT); | |
405 } | |
406 | |
407 #else /* no FF_ATI_BAT */ | |
408 | |
409 #ifdef WIN32 | |
410 ret=sAT_PlusCPOL(srcId,index,format, | |
411 ((op[0] NEQ 0x0)?op:NULL), | |
412 cpolIdx2, | |
413 cpolMode); | |
414 #else | |
415 ret=sAT_PlusCPOL((T_ACI_CMD_SRC)srcId,index,format, | |
416 ((op[0] NEQ 0x0)?op:NULL), | |
417 ACI_NumParmNotPresent, | |
418 CPOL_MOD_NotPresent); | |
419 #endif | |
420 | |
421 | |
422 switch (ret) | |
423 { | |
424 case (AT_CMPL): | |
425 return ATI_CMPL; | |
426 case (AT_EXCT): | |
427 src_params->curAtCmd = AT_CMD_CPOL; | |
428 return ATI_EXCT; | |
429 default: | |
430 cmdCmeError(CME_ERR_Unknown); | |
431 return ATI_FAIL; | |
432 } | |
433 #endif /* no FF_ATI_BAT */ | |
434 } | |
435 | |
436 GLOBAL T_ATI_RSLT tesatPlusCPOL (char *cl, UBYTE srcId) | |
437 { | |
438 SHORT lastIdx=0,usdNtry=0; | |
439 T_ACI_RETURN ret = AT_FAIL; | |
440 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
441 | |
442 TRACE_FUNCTION("tesatPlusCPOL()"); | |
443 | |
444 src_params->curAtCmd=AT_CMD_CPOL; | |
445 | |
446 #ifdef FF_ATI_BAT | |
447 { | |
448 T_BAT_cmd_send cmd; | |
449 T_BAT_no_parameter dummy; | |
450 | |
451 cmd.ctrl_params = BAT_CMD_TST_PLUS_CPOL; | |
452 dummy.bat_dummy = 0xFF; | |
453 cmd.params.ptr_tst_plus_cpol = &dummy; | |
454 bat_send(ati_bat_get_client(srcId), &cmd); | |
455 return(ATI_EXCT); | |
456 } | |
457 #else /* no FF_ATI_BAT */ | |
458 | |
459 ret = tAT_PlusCPOL((T_ACI_CMD_SRC)srcId,&lastIdx,&usdNtry); | |
460 if (ret EQ AT_CMPL) | |
461 { | |
462 sprintf(g_sa,"+CPOL: (1-%d),(0-2)", lastIdx); | |
463 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
464 } | |
465 if (ret EQ AT_EXCT) | |
466 { | |
467 src_params->curAtCmd = AT_CMD_CPOL; | |
468 } | |
469 if (ret EQ AT_FAIL) | |
470 { | |
471 cmdCmeError(CME_ERR_Unknown); | |
472 } | |
473 return (map_aci_2_ati_rslt(ret)); | |
474 | |
475 #endif /* no FF_ATI_BAT */ | |
476 } | |
477 | |
478 GLOBAL T_ATI_RSLT queatPlusCPOL (char *cl, UBYTE srcId) | |
479 { | |
480 #ifndef FF_ATI_BAT | |
481 T_ACI_CPOL_LST plmnSelLst; | |
482 UBYTE idx; | |
483 BOOL loop; | |
484 #endif | |
485 | |
486 SHORT startIdx=0,lastIdx=0; | |
487 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
488 | |
489 src_params->curAtCmd=AT_CMD_CPOL; | |
490 | |
491 TRACE_FUNCTION("queatPlusCPOL()"); | |
492 | |
493 #ifdef FF_ATI_BAT | |
494 { | |
495 T_BAT_cmd_send cmd; | |
496 T_BAT_no_parameter dummy; | |
497 | |
498 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CPOL; | |
499 dummy.bat_dummy = 0xFF; | |
500 cmd.params.ptr_que_plus_cpol = &dummy; | |
501 bat_send(ati_bat_get_client(srcId), &cmd); | |
502 return(ATI_EXCT); | |
503 } | |
504 #else /* no FF_ATI_BAT */ | |
505 | |
506 #ifdef WIN32 | |
507 switch (qAT_PlusCPOL ( srcId, | |
508 1, &lastIdx, | |
509 &plmnSelLst[0], | |
510 cpolMode)) | |
511 #else | |
512 switch (qAT_PlusCPOL ( (T_ACI_CMD_SRC)srcId, | |
513 1, &lastIdx, | |
514 &plmnSelLst[0], | |
515 CPOL_MOD_NotPresent)) | |
516 #endif | |
517 { | |
518 case AT_CMPL: | |
519 loop = TRUE; | |
520 do | |
521 { | |
522 if( lastIdx EQ ACI_NumParmNotPresent ) | |
523 break; | |
524 | |
525 startIdx = lastIdx+1; | |
526 | |
527 for( idx=0; idx < MAX_OPER; idx++ ) | |
528 { | |
529 if( plmnSelLst[idx].index EQ ACI_NumParmNotPresent ) | |
530 { | |
531 loop = FALSE; | |
532 break; | |
533 } | |
534 sprintf(g_sa,"+CPOL: %d,%d,\"%s\"", plmnSelLst[idx].index, | |
535 plmnSelLst[idx].format, | |
536 plmnSelLst[idx].oper ); | |
537 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
538 } | |
539 | |
540 if( qAT_PlusCPOL((T_ACI_CMD_SRC)srcId, startIdx, &lastIdx, &plmnSelLst[0], | |
541 #ifdef WIN32 | |
542 cpolMode | |
543 #else | |
544 CPOL_MOD_NotPresent | |
545 #endif | |
546 ) EQ AT_FAIL OR !loop) | |
547 { | |
548 break; | |
549 } | |
550 } | |
551 while( loop ); | |
552 return ATI_CMPL; | |
553 | |
554 case AT_EXCT: | |
555 src_params->curAtCmd = AT_CMD_CPOL; | |
556 return ATI_EXCT; | |
557 | |
558 default: | |
559 cmdCmeError(CME_ERR_Unknown); | |
560 return ATI_FAIL; | |
561 } | |
562 | |
563 #endif /* no FF_ATI_BAT */ | |
564 } | |
565 | |
566 /* | |
567 +--------------------------------------------------------------------+ | |
568 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
569 | STATE : code ROUTINE : atPlusCNUM | | |
570 +--------------------------------------------------------------------+ | |
571 | |
572 PURPOSE : +CNUM command (subscriber number) | |
573 */ | |
574 | |
575 GLOBAL T_ATI_RSLT setatPlusCNUM (char *cl, UBYTE srcId) | |
576 { | |
577 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
578 TRACE_FUNCTION("setatPlusCNUM()"); | |
579 | |
580 #ifdef FF_ATI_BAT | |
581 | |
582 { | |
583 T_BAT_cmd_send cmd; | |
584 T_BAT_no_parameter dummy; | |
585 | |
586 TRACE_FUNCTION("setatPlusCNUM() calls bat_send() <=== as APPLICATION"); | |
587 | |
588 cmd.ctrl_params = BAT_CMD_SET_PLUS_CNUM; | |
589 dummy.bat_dummy = 0xFF; | |
590 cmd.params.ptr_set_plus_cnum = &dummy; | |
591 | |
592 bat_send(ati_bat_get_client(srcId), &cmd); | |
593 | |
594 src_params->curAtCmd=AT_CMD_CNUM; | |
595 return(ATI_EXCT); | |
596 } | |
597 | |
598 #else /* no FF_ATI_BAT */ | |
599 | |
600 if ( qAT_PlusCNUM ( (T_ACI_CMD_SRC)srcId, CNUM_MOD_NewRead ) EQ AT_EXCT ) | |
601 { | |
602 src_params->curAtCmd = AT_CMD_CNUM; | |
603 return ATI_EXCT; | |
604 } | |
605 else | |
606 { | |
607 cmdCmeError ( CME_ERR_Unknown ); | |
608 return ATI_FAIL; | |
609 } | |
610 | |
611 #endif /* no FF_ATI_BAT */ | |
612 } | |
613 | |
614 | |
615 /* | |
616 +--------------------------------------------------------------------+ | |
617 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
618 | STATE : code ROUTINE : atPlusCFUN | | |
619 +--------------------------------------------------------------------+ | |
620 | |
621 PURPOSE : +CFUN command (Phone functionality) | |
622 */ | |
623 | |
624 GLOBAL T_ATI_RSLT setatPlusCFUN (char *cl, UBYTE srcId) | |
625 { | |
626 T_ACI_RETURN ret = AT_FAIL; | |
627 T_ACI_CFUN_FUN fun = CFUN_FUN_NotPresent; | |
628 T_ACI_CFUN_RST rst = CFUN_RST_NotPresent; | |
629 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
630 | |
631 src_params->curAtCmd = AT_CMD_CFUN; | |
632 | |
633 cl = parse (cl, "dd", &fun, &rst); | |
634 if ( !cl ) | |
635 { | |
636 cmdCmeError (CME_ERR_OpNotAllow); | |
637 return (ATI_FAIL); | |
638 } | |
639 | |
640 #ifdef FF_ATI_BAT | |
641 { | |
642 T_BAT_cmd_send cmd; | |
643 T_BAT_cmd_set_plus_cfun my_bat_set_plus_cfun; | |
644 | |
645 TRACE_FUNCTION("setatPlusCFUN() calls bat_send() <=== as APPLICATION"); | |
646 | |
647 memset(&my_bat_set_plus_cfun, FALSE, sizeof(my_bat_set_plus_cfun)); | |
648 cmd.ctrl_params = BAT_CMD_SET_PLUS_CFUN; | |
649 cmd.params.ptr_set_plus_cfun = &my_bat_set_plus_cfun; | |
650 | |
651 my_bat_set_plus_cfun.fun = (T_BAT_VAL_plus_cfun_fun)fun; | |
652 my_bat_set_plus_cfun.rst = (T_BAT_VAL_plus_cfun_rst)rst; | |
653 | |
654 | |
655 bat_send(ati_bat_get_client(srcId), &cmd); | |
656 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
657 } | |
658 #else /* no FF_ATI_BAT */ | |
659 { | |
660 TRACE_FUNCTION("setatPlusCFUN()"); | |
661 ret = sAT_PlusCFUN ((T_ACI_CMD_SRC)srcId,fun,rst); | |
662 switch (ret) | |
663 { | |
664 case AT_EXCT: /*Command is executing*/ | |
665 audio_SetAmplf (AUDIO_MICROPHONE, (UBYTE)75); | |
666 audio_SetAmplf (AUDIO_SPEAKER, (UBYTE)175); | |
667 src_params->curAtCmd = AT_CMD_CFUN; | |
668 break; | |
669 | |
670 case AT_CMPL: | |
671 src_params->curAtCmd = AT_CMD_NONE; | |
672 break; | |
673 | |
674 default: /* AT_FAIL or nothing was returned */ | |
675 cmdExtError (EXT_ERR_NotPresent); | |
676 break; | |
677 } | |
678 return (map_aci_2_ati_rslt (ret)); | |
679 } | |
680 #endif /* no FF_ATI_BAT */ | |
681 } | |
682 | |
683 GLOBAL T_ATI_RSLT queatPlusCFUN (char *cl, UBYTE srcId) | |
684 { | |
685 T_ACI_RETURN ret = AT_FAIL; | |
686 T_ACI_CFUN_FUN fun = CFUN_FUN_NotPresent; | |
687 | |
688 #ifdef FF_ATI_BAT | |
689 { | |
690 T_BAT_cmd_send cmd; | |
691 T_BAT_no_parameter dummy; | |
692 | |
693 TRACE_FUNCTION("queatPlusCFUN() calls bat_send() <=== as APPLICATION"); | |
694 | |
695 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CFUN; | |
696 dummy.bat_dummy = 0xFF; | |
697 cmd.params.ptr_que_plus_cfun = &dummy; | |
698 bat_send(ati_bat_get_client(srcId), &cmd); | |
699 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
700 } | |
701 #else /* no FF_ATI_BAT */ | |
702 TRACE_FUNCTION("queatPlusCFUN()"); | |
703 | |
704 ret = qAT_PlusCFUN((T_ACI_CMD_SRC)srcId, &fun); | |
705 if (ret EQ AT_CMPL) | |
706 { | |
707 resp_disp(srcId, cl,"e",&fun); | |
708 return ATI_CMPL; | |
709 } | |
710 else | |
711 { | |
712 cmdCmeError(CME_ERR_Unknown); | |
713 return ATI_FAIL; | |
714 } | |
715 #endif /* no FF_ATI_BAT */ | |
716 } | |
717 | |
718 /* | |
719 +--------------------------------------------------------------------+ | |
720 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
721 | STATE : code ROUTINE : atPlusCIMI | | |
722 +--------------------------------------------------------------------+ | |
723 | |
724 PURPOSE : +CIMI command (request international mobile subscriber | |
725 identity) | |
726 */ | |
727 GLOBAL T_ATI_RSLT setatPlusCIMI(char *cl, UBYTE srcId) | |
728 { | |
729 #ifndef FF_ATI_BAT | |
730 CHAR imsi[MAX_IMSI_LEN+1]; /* +1 for '\0' */ | |
731 #endif | |
732 | |
733 T_ACI_RETURN ret = AT_FAIL; | |
734 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
735 | |
736 TRACE_FUNCTION("setatPlusCIMI()"); | |
737 | |
738 #ifdef FF_ATI_BAT | |
739 | |
740 { | |
741 T_BAT_cmd_send cmd; | |
742 T_BAT_no_parameter dummy; | |
743 | |
744 TRACE_FUNCTION("setatPlusCIMI() calls bat_send() <=== as APPLICATION"); | |
745 | |
746 cmd.ctrl_params = BAT_CMD_SET_PLUS_CIMI; | |
747 dummy.bat_dummy = 0xFF; | |
748 cmd.params.ptr_set_plus_cimi = &dummy; | |
749 | |
750 bat_send(ati_bat_get_client(srcId), &cmd); | |
751 | |
752 src_params->curAtCmd=AT_CMD_CIMI; | |
753 return(ATI_EXCT); | |
754 } | |
755 | |
756 #else /* no FF_ATI_BAT */ | |
757 | |
758 ret = qAT_PlusCIMI((T_ACI_CMD_SRC)srcId, imsi); | |
759 switch (ret) | |
760 { | |
761 case( AT_CMPL ): | |
762 | |
763 sprintf(g_sa,"%s",imsi); | |
764 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
765 break; | |
766 | |
767 case( AT_EXCT ): | |
768 src_params->curAtCmd = AT_CMD_CIMI; | |
769 break; | |
770 | |
771 default: | |
772 | |
773 break; | |
774 } | |
775 return (map_aci_2_ati_rslt(ret)); | |
776 | |
777 #endif /* no FF_ATI_BAT */ | |
778 } | |
779 | |
780 | |
781 /* | |
782 +--------------------------------------------------------------------+ | |
783 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
784 | STATE : code ROUTINE : atPlusCRSM | | |
785 +--------------------------------------------------------------------+ | |
786 | |
787 PURPOSE : +CRSM Restricted SIM access | |
788 */ | |
789 GLOBAL T_ATI_RSLT setatPlusCRSM(char *cl, UBYTE srcId) | |
790 { | |
791 T_ACI_RETURN ret = AT_FAIL; | |
792 UBYTE *data; | |
793 USHORT lenData = 0; | |
794 T_ACI_CRSM_CMD cmd = CRSM_CMD_NotPresent; | |
795 SHORT fileId = ACI_NumParmNotPresent, | |
796 p1 = ACI_NumParmNotPresent, | |
797 p2 = ACI_NumParmNotPresent, | |
798 p3 = ACI_NumParmNotPresent; | |
799 USHORT lenDataStr = 0; | |
800 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
801 | |
802 | |
803 TRACE_FUNCTION("setatPlusCRSM"); | |
804 | |
805 cl = parse(cl,"drrrrl", &cmd,&fileId, &p1, &p2, &p3,&lenDataStr,&data ); | |
806 if(!cl) | |
807 { | |
808 cmdCmeError(CME_ERR_OpNotAllow); | |
809 return ATI_FAIL; | |
810 } | |
811 | |
812 utl_hexToGsm( data, lenDataStr, data, &lenData, GSM_ALPHA_Def, | |
813 CSCS_ALPHA_Reserved ); | |
814 | |
815 #ifdef FF_ATI_BAT | |
816 { | |
817 T_BAT_cmd_send bat_cmd; | |
818 T_BAT_cmd_set_plus_crsm crsm; | |
819 | |
820 /* | |
821 * If the data is too big for the BAT structure, there's | |
822 * nothing we can do. A truncated version would be meaningless. | |
823 */ | |
824 if (lenData>BAT_MAX_CRSM_DATA_LEN) | |
825 return(ATI_FAIL); | |
826 | |
827 bat_cmd.ctrl_params = BAT_CMD_SET_PLUS_CRSM; | |
828 bat_cmd.params.ptr_set_plus_crsm=&crsm; | |
829 | |
830 /* | |
831 * This relies on T_ACI_CRSM_COMMAND and T_BAT_plus_crsm_command | |
832 * being identical. They are, except in that the ACI version has | |
833 * a 'not present' value. This is not an issue in this direction. | |
834 */ | |
835 crsm.command=(T_BAT_plus_crsm_command)cmd; | |
836 | |
837 crsm.fileid=(S32)fileId; | |
838 crsm.p1=(S16)p1; | |
839 crsm.p2=(S16)p2; | |
840 crsm.p3=(S16)p3; | |
841 crsm.c_data=(U8)lenData; | |
842 memcpy(crsm.data,data,lenData); | |
843 | |
844 bat_send(ati_bat_get_client(srcId),&bat_cmd); | |
845 | |
846 src_params->curAtCmd=AT_CMD_CRSM; | |
847 return(ATI_EXCT); | |
848 } | |
849 #else /* no FF_ATI_BAT */ | |
850 | |
851 ret = sAT_PlusCRSM( (T_ACI_CMD_SRC)srcId, cmd, fileId, p1, p2, p3, | |
852 lenData, data ); | |
853 if (ret EQ AT_EXCT) | |
854 { | |
855 src_params->curAtCmd = AT_CMD_CRSM; | |
856 } | |
857 if (ret EQ AT_FAIL) | |
858 { | |
859 cmdCmeError(CME_ERR_Unknown); | |
860 } | |
861 return (map_aci_2_ati_rslt(ret)); | |
862 | |
863 #endif /* no FF_ATI_BAT */ | |
864 } | |
865 | |
866 /* | |
867 +--------------------------------------------------------------------+ | |
868 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
869 | STATE : code ROUTINE : setatPlusCSIM | | |
870 +--------------------------------------------------------------------+ | |
871 | |
872 PURPOSE : +CSIM Generic SIM access | |
873 */ | |
874 GLOBAL T_ATI_RSLT setatPlusCSIM(char *cl, UBYTE srcId) | |
875 { | |
876 T_ACI_RETURN ret = AT_FAIL; | |
877 USHORT given_length; | |
878 UBYTE *data; | |
879 USHORT lenData = 0; | |
880 USHORT lenDataStr = 0; | |
881 | |
882 | |
883 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
884 | |
885 | |
886 TRACE_FUNCTION("setatPlusCSIM"); | |
887 | |
888 cl = parse(cl,"rl", &given_length, &lenDataStr, &data ); | |
889 if(!cl) | |
890 { | |
891 cmdCmeError(CME_ERR_OpNotAllow); | |
892 return ATI_FAIL; | |
893 } | |
894 | |
895 if ((given_length > MAX_SIM_TRANSP*2) | |
896 OR (given_length NEQ lenDataStr) | |
897 OR (lenDataStr EQ 0)) | |
898 { | |
899 cmdCmeError(CME_ERR_OpNotAllow); | |
900 return ATI_FAIL; | |
901 } | |
902 | |
903 lenData = utl_HexStrToBin(data, lenDataStr, data, MAX_SIM_TRANSP); | |
904 | |
905 if (lenData EQ 0) | |
906 { | |
907 TRACE_EVENT("invalid character in <command>"); | |
908 cmdCmeError(CME_ERR_OpNotAllow); | |
909 return ATI_FAIL; | |
910 } | |
911 | |
912 #ifdef FF_ATI_BAT | |
913 | |
914 { | |
915 T_BAT_cmd_send bat_cmd; | |
916 T_BAT_cmd_set_plus_csim csim; | |
917 | |
918 /* | |
919 * If the data is too big for the BAT structure, there's | |
920 * nothing we can do. A truncated version would be meaningless. | |
921 */ | |
922 if (lenData>BAT_MAX_CSIM_CMD_LEN) | |
923 return(ATI_FAIL); | |
924 | |
925 bat_cmd.ctrl_params = BAT_CMD_SET_PLUS_CSIM; | |
926 bat_cmd.params.ptr_set_plus_csim=&csim; | |
927 | |
928 csim.c_command=(U8)lenData; | |
929 memcpy(csim.command,data,lenData); | |
930 | |
931 bat_send(ati_bat_get_client(srcId),&bat_cmd); | |
932 | |
933 src_params->curAtCmd=AT_CMD_CRSM; | |
934 return(ATI_EXCT); | |
935 } | |
936 | |
937 #else /* no FF_ATI_BAT */ | |
938 | |
939 ret = sAT_PlusCSIM( (T_ACI_CMD_SRC)srcId, lenData, data ); | |
940 if (ret EQ AT_EXCT) | |
941 { | |
942 src_params->curAtCmd = AT_CMD_CSIM; | |
943 } | |
944 if (ret EQ AT_FAIL) | |
945 { | |
946 cmdCmeError(CME_ERR_Unknown); | |
947 } | |
948 return (map_aci_2_ati_rslt(ret)); | |
949 | |
950 #endif /* no FF_ATI_BAT */ | |
951 } | |
952 | |
953 #ifdef TI_PS_FF_AT_P_CMD_ATR | |
954 /* | |
955 +--------------------------------------------------------------------+ | |
956 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
957 | STATE : code ROUTINE : queatPercentATR | | |
958 +--------------------------------------------------------------------+ | |
959 | |
960 PURPOSE : %ATR answer to reset (query) | |
961 */ | |
962 GLOBAL T_ATI_RSLT queatPercentATR ( char *cl, UBYTE srcId ) | |
963 { | |
964 #ifndef FF_ATI_BAT | |
965 T_ACI_RETURN ret; | |
966 UBYTE i; | |
967 UBYTE phase; | |
968 UBYTE atr_len = 0; | |
969 UBYTE atr_info[MAX_SIM_ATR]; | |
970 #endif | |
971 | |
972 TRACE_FUNCTION( "queatPercentATR()" ); | |
973 | |
974 #ifdef FF_ATI_BAT | |
975 { | |
976 T_BAT_cmd_send cmd; | |
977 T_BAT_no_parameter dummy; | |
978 | |
979 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_ATR; | |
980 dummy.bat_dummy = 0xFF; | |
981 cmd.params.ptr_que_percent_atr = &dummy; | |
982 | |
983 /* | |
984 * Without this we will lose track of the source ID by the time the | |
985 * response arrives. | |
986 */ | |
987 srcId_cb=srcId; | |
988 | |
989 bat_send(ati_bat_get_client(srcId), &cmd); | |
990 return(ATI_EXCT); | |
991 } | |
992 #else /* no FF_ATI_BAT */ | |
993 | |
994 ret = qAT_PercentATR( (T_ACI_CMD_SRC)srcId, &phase, &atr_len, atr_info ); | |
995 | |
996 if( ret NEQ AT_CMPL ) | |
997 { | |
998 cmdCmeError(CME_ERR_Unknown); | |
999 } | |
1000 else | |
1001 { | |
1002 if(phase NEQ NOT_PRESENT_8BIT) | |
1003 { | |
1004 i=sprintf(g_sa,"%s%d,", "%ATR: ", phase);/* if phase available.. return phase*/ | |
1005 } | |
1006 else | |
1007 { | |
1008 i=sprintf(g_sa,"%s", "%ATR: FFFF");/* else return FFFF*/ | |
1009 } | |
1010 | |
1011 if(atr_len) /* if ATR data available... return ATR data*/ | |
1012 { | |
1013 sprintf(g_sa+i,","); | |
1014 utl_binToHex( atr_info, atr_len, g_sa+i ); | |
1015 } | |
1016 | |
1017 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1018 } | |
1019 return (map_aci_2_ati_rslt(ret)); | |
1020 | |
1021 #endif /* no FF_ATI_BAT */ | |
1022 } | |
1023 #endif /* TI_PS_FF_AT_P_CMD_ATR */ | |
1024 | |
1025 /* | |
1026 +--------------------------------------------------------------------+ | |
1027 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1028 | STATE : code ROUTINE : setatPercentCPRI | | |
1029 +--------------------------------------------------------------------+ | |
1030 | |
1031 PURPOSE : %CPRI command (select cipher indication mode) | |
1032 */ | |
1033 | |
1034 GLOBAL T_ATI_RSLT setatPercentCPRI ( char *cl, UBYTE srcId ) | |
1035 { | |
1036 T_ACI_RETURN ACI_return = AT_FAIL; | |
1037 UBYTE CPRImode; | |
1038 | |
1039 TRACE_FUNCTION( "setatPercentCPRI()" ); | |
1040 | |
1041 switch( *cl ) | |
1042 { | |
1043 case '0': | |
1044 case '1': | |
1045 CPRImode = *cl - 0x30; /* make binary value */ | |
1046 cl++; | |
1047 ACI_return = sAT_PercentCPRI( (T_ACI_CMD_SRC)srcId, CPRImode ); | |
1048 if( ACI_return NEQ AT_CMPL ) | |
1049 { | |
1050 cmdCmeError(CME_ERR_Unknown); | |
1051 } | |
1052 else /* If ACI_return is AT_CMPL,updates the CPRI_stat with CPRImode */ | |
1053 { | |
1054 ati_user_output_cfg[srcId].CPRI_stat = CPRImode; | |
1055 } | |
1056 break; | |
1057 default: | |
1058 cmdCmeError(CME_ERR_OpNotAllow); | |
1059 break; | |
1060 } | |
1061 return (map_aci_2_ati_rslt(ACI_return)); | |
1062 } | |
1063 | |
1064 | |
1065 GLOBAL T_ATI_RSLT queatPercentCPRI ( char *cl, UBYTE srcId ) | |
1066 { | |
1067 T_ACI_RETURN ACI_return = AT_FAIL; | |
1068 UBYTE CPRIenabled; | |
1069 | |
1070 TRACE_FUNCTION( "queatPercentCPRI()" ); | |
1071 | |
1072 ACI_return = qAT_PercentCPRI( (T_ACI_CMD_SRC)srcId, &CPRIenabled ); | |
1073 | |
1074 if( ACI_return NEQ AT_CMPL ) | |
1075 { | |
1076 cmdCmeError(CME_ERR_Unknown); | |
1077 } | |
1078 else | |
1079 { | |
1080 if (CPRIenabled) | |
1081 { | |
1082 CPRIenabled = ati_user_output_cfg[srcId].CPRI_stat; | |
1083 } | |
1084 else | |
1085 { | |
1086 CPRIenabled = CI_DISABLED; | |
1087 } | |
1088 resp_disp(srcId, cl,"b",&CPRIenabled); | |
1089 } | |
1090 return (map_aci_2_ati_rslt(ACI_return)); | |
1091 } | |
1092 | |
1093 /* | |
1094 +--------------------------------------------------------------------+ | |
1095 | PROJECT : GSM-F&D (8411) MODULE : | | |
1096 | STATE : code ROUTINE : setatPercentPVRF | | |
1097 +--------------------------------------------------------------------+ | |
1098 | |
1099 PURPOSE : return information relating to status of PIN. | |
1100 | |
1101 */ | |
1102 | |
1103 GLOBAL T_ATI_RSLT setatPercentPVRF( char *cl, UBYTE srcId ) | |
1104 { | |
1105 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1106 T_ACI_PVRF_TYPE type; | |
1107 CHAR pin[10]; | |
1108 CHAR newpin[10]; | |
1109 T_ACI_RETURN ret = AT_FAIL; | |
1110 | |
1111 TRACE_FUNCTION( "setatPercentPVRF()" ); | |
1112 | |
1113 /* parse mode */ | |
1114 cl = parse (cl, "dss", &type, (LONG) sizeof (pin),pin, (LONG) sizeof (newpin), newpin); | |
1115 if (!cl OR (type > PVRF_TYPE_Puk2) OR (type <= PVRF_TYPE_NotPresent))/*lint !e685 (Warning -- :685 Relational operator '>' always evaluates to 'false ) */ | |
1116 { | |
1117 cmdCmeError (CME_ERR_OpNotAllow); | |
1118 return (ATI_FAIL); | |
1119 } | |
1120 | |
1121 #ifdef FF_ATI_BAT | |
1122 | |
1123 { | |
1124 T_BAT_cmd_send cmd; | |
1125 T_BAT_cmd_set_percent_pvrf pvrf; | |
1126 UBYTE len; | |
1127 | |
1128 cmd.ctrl_params = BAT_CMD_SET_PERCENT_PVRF; | |
1129 cmd.params.ptr_set_percent_pvrf=&pvrf; | |
1130 | |
1131 /* | |
1132 * This relies on T_ACI_PVRF_TYPE and T_BAT_percent_pvrf_type | |
1133 * being identical. They are, except in that the ACI version has | |
1134 * a 'not present' value. In this direction, that doesn't matter. | |
1135 */ | |
1136 pvrf.type=(T_BAT_percent_pvrf_type)type; | |
1137 | |
1138 len=strlen(pin); | |
1139 if (len>BAT_MAX_PVRF_PIN_LEN) | |
1140 return(ATI_FAIL); | |
1141 | |
1142 pvrf.c_pin=(U8)len; | |
1143 memcpy(pvrf.pin,pin,len); | |
1144 | |
1145 len=strlen(newpin); | |
1146 if (len>BAT_MAX_PVRF_NEW_PIN_LEN) | |
1147 return(ATI_FAIL); | |
1148 | |
1149 if (len) | |
1150 { | |
1151 pvrf.v_newpin=TRUE; | |
1152 pvrf.c_newpin=(U8)len; | |
1153 memcpy(pvrf.newpin,newpin,len); | |
1154 } | |
1155 else | |
1156 { | |
1157 pvrf.v_newpin=FALSE; | |
1158 } | |
1159 bat_send(ati_bat_get_client(srcId), &cmd); | |
1160 | |
1161 src_params->curAtCmd=AT_CMD_PVRF; | |
1162 return(ATI_EXCT); | |
1163 } | |
1164 | |
1165 #else /* no FF_ATI_BAT */ | |
1166 | |
1167 ret = sAT_PercentPVRF ((T_ACI_CMD_SRC)srcId, type, pin, newpin); | |
1168 | |
1169 switch (ret) | |
1170 { | |
1171 case (AT_CMPL): /*operation completed*/ | |
1172 break; | |
1173 case (AT_EXCT): | |
1174 src_params->curAtCmd = AT_CMD_PVRF; | |
1175 break; | |
1176 default: | |
1177 cmdCmeError(CME_ERR_Unknown); /*Command failed*/ | |
1178 break; | |
1179 } | |
1180 return (map_aci_2_ati_rslt(ret)); | |
1181 | |
1182 #endif /* no FF_ATI_BAT */ | |
1183 } | |
1184 | |
1185 /* | |
1186 +--------------------------------------------------------------------+ | |
1187 | PROJECT : GPRS (8441) MODULE : GACI_CMD | | |
1188 | STATE : code ROUTINE : queatPercentPVRF | | |
1189 +--------------------------------------------------------------------+ | |
1190 | |
1191 PURPOSE : %PVRF command | |
1192 */ | |
1193 GLOBAL T_ATI_RSLT queatPercentPVRF (char *cl, UBYTE srcId) | |
1194 { | |
1195 TRACE_FUNCTION("queatPercentPVRF()"); | |
1196 | |
1197 #ifdef FF_ATI_BAT | |
1198 { | |
1199 T_BAT_cmd_send cmd; | |
1200 T_BAT_no_parameter dummy; | |
1201 | |
1202 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_PVRF; | |
1203 dummy.bat_dummy = 0xFF; | |
1204 cmd.params.ptr_que_percent_pvrf = &dummy; | |
1205 bat_send(ati_bat_get_client(srcId), &cmd); | |
1206 return(ATI_EXCT); | |
1207 } | |
1208 #else /* no FF_ATI_BAT */ | |
1209 { | |
1210 T_ACI_PVRF_STAT ps1; | |
1211 T_ACI_PVRF_STAT ps2; | |
1212 CHAR *me = "%PVRF: "; | |
1213 SHORT pn1cnt = 0; | |
1214 SHORT pn2cnt = 0; | |
1215 SHORT pk1cnt = 0; | |
1216 SHORT pk2cnt = 0; | |
1217 | |
1218 T_ACI_RETURN ret = qAT_PercentPVRF((T_ACI_CMD_SRC)srcId, &pn1cnt, &pn2cnt, &pk1cnt, &pk2cnt, &ps1, &ps2); | |
1219 | |
1220 if (ret NEQ AT_CMPL) | |
1221 { | |
1222 cmdCmeError(CME_ERR_Unknown); | |
1223 return (ATI_FAIL); | |
1224 } | |
1225 | |
1226 sprintf(g_sa,"%s%d, %d, %d, %d, %d, %d", me, pn1cnt, pn2cnt, pk1cnt, pk2cnt, ps1, ps2); | |
1227 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1228 | |
1229 return (ATI_CMPL); | |
1230 } | |
1231 #endif /* no FF_ATI_BAT */ | |
1232 } | |
1233 | |
1234 #ifdef TI_PS_FF_AT_P_CMD_CUST | |
1235 /* | |
1236 +--------------------------------------------------------------------+ | |
1237 | PROJECT : GSM-F&D (8411) MODULE : | | |
1238 | STATE : code ROUTINE : setatPercentCUST | | |
1239 +--------------------------------------------------------------------+ | |
1240 | |
1241 PURPOSE : %CUST command ( Set Customisation Mode Function ) | |
1242 */ | |
1243 | |
1244 GLOBAL T_ATI_RSLT setatPercentCUST ( char *cl, UBYTE srcId ) /* Function protype is T_ATI_RSLT not T_ACI_RETURN so it is changed */ | |
1245 { | |
1246 TRACE_FUNCTION( "setatPercentCUST()" ); | |
1247 | |
1248 #ifdef FF_ATI_BAT | |
1249 | |
1250 { | |
1251 T_BAT_cmd_send cmd; | |
1252 T_BAT_cmd_set_percent_cust cust; | |
1253 | |
1254 cmd.ctrl_params = BAT_CMD_SET_PERCENT_CUST; | |
1255 cmd.params.ptr_set_percent_cust=&cust; | |
1256 | |
1257 switch (*cl) | |
1258 { | |
1259 case '0': | |
1260 cust.mode=BAT_P_CUST_MODE_NORMAL; | |
1261 break; | |
1262 | |
1263 case '1': | |
1264 cust.mode=BAT_P_CUST_MODE_BEHAVIOUR_1; | |
1265 break; | |
1266 | |
1267 default: | |
1268 cmdCmeError(CME_ERR_OpNotAllow); | |
1269 return(ATI_FAIL); | |
1270 } | |
1271 bat_send(ati_bat_get_client(srcId), &cmd); | |
1272 | |
1273 return(ATI_EXCT); | |
1274 } | |
1275 #else /* no FF_ATI_BAT */ | |
1276 | |
1277 switch( *cl ) | |
1278 { | |
1279 case '0': | |
1280 if (sAT_PercentCUST((T_ACI_CMD_SRC)srcId, CUST_NORMAL_BEHAVIOUR) EQ AT_FAIL) | |
1281 { | |
1282 cmdCmeError(CME_ERR_Unknown); | |
1283 return (ATI_FAIL); | |
1284 } | |
1285 break; | |
1286 | |
1287 case '1': | |
1288 if (sAT_PercentCUST ((T_ACI_CMD_SRC)srcId, CUST_MODE_BEHAVIOUR_1) EQ AT_FAIL) | |
1289 { | |
1290 cmdCmeError(CME_ERR_Unknown); | |
1291 return (ATI_FAIL); | |
1292 } | |
1293 break; | |
1294 | |
1295 default: | |
1296 cmdCmeError(CME_ERR_OpNotAllow); | |
1297 return (ATI_FAIL); | |
1298 } | |
1299 | |
1300 return (ATI_CMPL); | |
1301 | |
1302 #endif /* no FF_ATI_BAT */ | |
1303 } | |
1304 | |
1305 /* | |
1306 +--------------------------------------------------------------------+ | |
1307 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1308 | STATE : code ROUTINE : queatPercentCUST | | |
1309 +--------------------------------------------------------------------+ | |
1310 | |
1311 PURPOSE : %CUST command (Customisaton Mode) | |
1312 */ | |
1313 GLOBAL T_ATI_RSLT queatPercentCUST (char *cl, UBYTE srcId) | |
1314 { | |
1315 TRACE_FUNCTION("queatPercentCUST()"); | |
1316 | |
1317 #ifdef FF_ATI_BAT | |
1318 { | |
1319 T_BAT_cmd_send cmd; | |
1320 T_BAT_no_parameter dummy; | |
1321 | |
1322 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_CUST; | |
1323 dummy.bat_dummy = 0xFF; | |
1324 cmd.params.ptr_que_percent_cust = &dummy; | |
1325 bat_send(ati_bat_get_client(srcId), &cmd); | |
1326 return(ATI_EXCT); | |
1327 } | |
1328 #else /* no FF_ATI_BAT */ | |
1329 { | |
1330 T_CUST_MOD mode; | |
1331 T_ACI_RETURN ret = qAT_PercentCUST((T_ACI_CMD_SRC)srcId, &mode); | |
1332 | |
1333 if (ret NEQ AT_CMPL) | |
1334 { | |
1335 cmdCmeError(CME_ERR_Unknown); | |
1336 return (ATI_FAIL); | |
1337 } | |
1338 | |
1339 sprintf(g_sa,"%%CUST: %d", mode); | |
1340 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1341 | |
1342 return ATI_CMPL; | |
1343 } | |
1344 #endif /* no FF_ATI_BAT */ | |
1345 } | |
1346 #endif /* TI_PS_FF_AT_P_CMD_CUST */ | |
1347 /* | |
1348 +--------------------------------------------------------------------+ | |
1349 | PROJECT : GSM-F&D (8411) MODULE : | | |
1350 | STATE : code ROUTINE : setatPercentSATCC | | |
1351 +--------------------------------------------------------------------+ | |
1352 | |
1353 PURPOSE : %SATCC command ( Enable/Disable the Call/Short Message Control By SIM ) | |
1354 */ | |
1355 | |
1356 GLOBAL T_ATI_RSLT setatPercentSATCC ( char *cl, UBYTE srcId ) /* Function protype is T_ATI_RSLT not T_ACI_RETURN so it is changed */ | |
1357 | |
1358 { | |
1359 #ifdef FF_ATI_BAT | |
1360 T_BAT_cmd_send bat_cmd; | |
1361 T_BAT_cmd_set_percent_satcc satcc; | |
1362 #endif | |
1363 TRACE_FUNCTION( "setatPercentSATCC()" ); | |
1364 | |
1365 #ifdef FF_ATI_BAT | |
1366 switch( *cl ) | |
1367 { | |
1368 case '0': | |
1369 satcc.mode = BAT_P_SATCC_MODE_INACTIVE; | |
1370 break; | |
1371 case '1': | |
1372 satcc.mode = BAT_P_SATCC_MODE_ACTIVE; | |
1373 break; | |
1374 default: | |
1375 cmdCmeError(CME_ERR_Unknown); | |
1376 return (ATI_FAIL); | |
1377 } | |
1378 | |
1379 bat_cmd.ctrl_params = BAT_CMD_SET_PERCENT_SATCC; | |
1380 bat_cmd.params.ptr_set_percent_satcc = &satcc; | |
1381 | |
1382 bat_send(ati_bat_get_client(srcId),&bat_cmd); | |
1383 | |
1384 return(ATI_EXCT); | |
1385 | |
1386 #else | |
1387 switch( *cl ) | |
1388 { | |
1389 case '0': | |
1390 if (sAT_PercentSATCC((T_ACI_CMD_SRC)srcId, SATCC_CONTROL_BY_SIM_INACTIVE) EQ AT_FAIL) | |
1391 { | |
1392 cmdCmeError(CME_ERR_Unknown); | |
1393 return (ATI_FAIL); | |
1394 } | |
1395 break; | |
1396 | |
1397 case '1': | |
1398 if (sAT_PercentSATCC ((T_ACI_CMD_SRC)srcId, SATCC_CONTROL_BY_SIM_ACTIVE) EQ AT_FAIL) | |
1399 { | |
1400 cmdCmeError(CME_ERR_Unknown); | |
1401 return (ATI_FAIL); | |
1402 } | |
1403 break; | |
1404 | |
1405 default: | |
1406 cmdCmeError(CME_ERR_OpNotAllow); | |
1407 return (ATI_FAIL); | |
1408 } | |
1409 | |
1410 return (ATI_CMPL); | |
1411 | |
1412 #endif | |
1413 } | |
1414 | |
1415 /* | |
1416 +--------------------------------------------------------------------+ | |
1417 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1418 | STATE : code ROUTINE : queatPercentSATCC | | |
1419 +--------------------------------------------------------------------+ | |
1420 | |
1421 PURPOSE : %SATCC command (Query Call/Short Message control By SIM) | |
1422 */ | |
1423 GLOBAL T_ATI_RSLT queatPercentSATCC (char *cl, UBYTE srcId) | |
1424 { | |
1425 #ifdef FF_ATI_BAT | |
1426 T_BAT_cmd_send bat_cmd; | |
1427 T_BAT_no_parameter satcc; | |
1428 #else | |
1429 T_SAT_CC_MOD mode; | |
1430 T_ACI_RETURN ret = AT_FAIL; | |
1431 #endif | |
1432 | |
1433 TRACE_FUNCTION("queatPercentSATCC()"); | |
1434 | |
1435 #ifdef FF_ATI_BAT | |
1436 bat_cmd.ctrl_params = BAT_CMD_QUE_PERCENT_SATCC; | |
1437 bat_cmd.params.ptr_que_percent_satcc = &satcc; | |
1438 | |
1439 bat_send(ati_bat_get_client(srcId),&bat_cmd); | |
1440 | |
1441 return(ATI_EXCT); | |
1442 | |
1443 #else | |
1444 | |
1445 ret = qAT_PercentSATCC((T_ACI_CMD_SRC)srcId, &mode); | |
1446 | |
1447 if (ret NEQ AT_CMPL) | |
1448 { | |
1449 cmdCmeError(CME_ERR_Unknown); | |
1450 return (ATI_FAIL); | |
1451 } | |
1452 | |
1453 sprintf(g_sa,"%%SATCC: %d", mode); | |
1454 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1455 | |
1456 #endif /*FF_ATI_BAT*/ | |
1457 | |
1458 return ATI_CMPL; | |
1459 } | |
1460 | |
1461 /* | |
1462 +--------------------------------------------------------------------+ | |
1463 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1464 | STATE : code ROUTINE : setatPercentSIMIND | | |
1465 +--------------------------------------------------------------------+ | |
1466 | |
1467 PURPOSE : enable %SIMINS / %SIMREM indications | |
1468 */ | |
1469 | |
1470 GLOBAL T_ATI_RSLT setatPercentSIMIND(char *cl, UBYTE srcId) | |
1471 { | |
1472 int mode = 1; | |
1473 | |
1474 TRACE_FUNCTION("setatPercentSIMIND()"); | |
1475 | |
1476 /* parse mode */ | |
1477 cl = parse (cl, "d", &mode); | |
1478 | |
1479 if (mode EQ 0 OR mode EQ 1) | |
1480 { | |
1481 ati_user_output_cfg[srcId].SIMIND_stat = mode; | |
1482 return (ATI_CMPL); | |
1483 } | |
1484 else | |
1485 { | |
1486 cmdCmeError(CME_ERR_OpNotAllow); | |
1487 return (ATI_FAIL); | |
1488 } | |
1489 } | |
1490 | |
1491 /* | |
1492 +--------------------------------------------------------------------+ | |
1493 | PROJECT : GPRS (8441) MODULE : ACI_CMD | | |
1494 | STATE : code ROUTINE : queatPercentSIMIND | | |
1495 +--------------------------------------------------------------------+ | |
1496 | |
1497 PURPOSE : query status of %SIMINS / %SIMREM indications | |
1498 */ | |
1499 GLOBAL T_ATI_RSLT queatPercentSIMIND(char *cl, UBYTE srcId) | |
1500 { | |
1501 CHAR *me = "%SIMIND"; | |
1502 | |
1503 TRACE_FUNCTION("queatPercentSIMIND()"); | |
1504 | |
1505 sprintf(g_sa,"%s: %d", me, ati_user_output_cfg[srcId].SIMIND_stat); | |
1506 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1507 | |
1508 return (ATI_CMPL); | |
1509 } | |
1510 | |
1511 #ifdef FF_DUAL_SIM | |
1512 /* | |
1513 +--------------------------------------------------------------------+ | |
1514 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1515 | STATE : code ROUTINE : atPlusCFUN | | |
1516 +--------------------------------------------------------------------+ | |
1517 | |
1518 PURPOSE : %SIM command (SIM Selection) | |
1519 */ | |
1520 | |
1521 GLOBAL T_ATI_RSLT setatPercentSIM (char *cl, UBYTE srcId) | |
1522 { | |
1523 T_ACI_RETURN ret = AT_FAIL; | |
1524 UBYTE sim_num; | |
1525 | |
1526 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1527 | |
1528 TRACE_FUNCTION("setatPercentSIM()"); | |
1529 | |
1530 /*input functionality*/ | |
1531 cl = parse (cl,"d",&sim_num); | |
1532 if ( !cl ) | |
1533 { | |
1534 cmdCmeError (CME_ERR_OpNotAllow); | |
1535 return(ATI_FAIL); | |
1536 } | |
1537 | |
1538 ret = sAT_PercentSIM (srcId,sim_num); | |
1539 switch (ret) | |
1540 { | |
1541 case AT_EXCT: /*Command is executing*/ | |
1542 src_params->curAtCmd = AT_CMD_SIM; | |
1543 break; | |
1544 | |
1545 case AT_FAIL: | |
1546 src_params->curAtCmd = AT_CMD_NONE; | |
1547 break; | |
1548 | |
1549 default: | |
1550 cmdCmeError(CME_ERR_Unknown); | |
1551 break; | |
1552 } | |
1553 return (map_aci_2_ati_rslt (ret)); | |
1554 } | |
1555 | |
1556 GLOBAL T_ATI_RSLT queatPercentSIM (char *cl, UBYTE srcId) | |
1557 { | |
1558 T_ACI_RETURN ret = AT_FAIL; | |
1559 UBYTE sim_num; | |
1560 | |
1561 TRACE_FUNCTION("queatPercentSIM()"); | |
1562 | |
1563 ret = qAT_PercentSIM(srcId, &sim_num); | |
1564 | |
1565 if (ret EQ AT_CMPL) | |
1566 { | |
1567 resp_disp(srcId, cl,"b",&sim_num); | |
1568 return ATI_CMPL; | |
1569 } | |
1570 else | |
1571 { | |
1572 cmdCmeError(CME_ERR_Unknown); | |
1573 return ATI_FAIL; | |
1574 } | |
1575 } | |
1576 #endif /*FF_DUAL_SIM*/ | |
1577 | |
1578 #ifdef FF_CPHS_REL4 | |
1579 /* | |
1580 +--------------------------------------------------------------------+ | |
1581 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1582 | STATE : code ROUTINE : setatPercentCFIS | | |
1583 +--------------------------------------------------------------------+ | |
1584 | |
1585 PURPOSE : %CFIS command (Call Forwarding Unconditional) | |
1586 */ | |
1587 | |
1588 GLOBAL T_ATI_RSLT setatPercentCFIS (char *cl, UBYTE srcId) | |
1589 { | |
1590 T_ACI_RETURN ret = AT_FAIL; | |
1591 T_ACI_CFIS_MOD cfisMode = CFIS_MOD_NotPresent; | |
1592 UBYTE index = NOT_PRESENT_8BIT; | |
1593 UBYTE mspId; | |
1594 UBYTE cfuStat; | |
1595 CHAR number[MAX_PHB_NUM_LEN]; | |
1596 T_ACI_TOA type; | |
1597 T_ACI_TOA *p_type; | |
1598 SHORT toa_oct = 0; | |
1599 UBYTE cc2_Id = NOT_PRESENT_8BIT; | |
1600 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1601 | |
1602 TRACE_FUNCTION( "setatPercentCFIS()" ); | |
1603 | |
1604 /* init */ | |
1605 memset( number, 0, sizeof(number)); | |
1606 | |
1607 cl = parse (cl, "ddddsdd", &cfisMode, &index, &mspId, &cfuStat, | |
1608 (LONG)MAX_PHB_NUM_LEN, number, &toa_oct , &cc2_Id); | |
1609 | |
1610 if(!cl) | |
1611 { | |
1612 cmdCmeError(CME_ERR_OpNotAllow); | |
1613 return (ATI_FAIL); | |
1614 } | |
1615 | |
1616 if (toa_oct EQ 0) | |
1617 { | |
1618 p_type = NULL; | |
1619 } | |
1620 else | |
1621 { | |
1622 type=toa_demerge(toa_oct); | |
1623 p_type = &type; | |
1624 } | |
1625 | |
1626 if( cfisMode EQ CFIS_MOD_Read) | |
1627 { | |
1628 ret=qAT_PercentCFIS(srcId, index ); | |
1629 } | |
1630 else | |
1631 { | |
1632 ret = sAT_PercentCFIS(srcId, cfisMode,index,mspId, cfuStat, | |
1633 number, p_type, cc2_Id); | |
1634 } | |
1635 | |
1636 switch (ret) | |
1637 { | |
1638 case AT_EXCT: /*Command is executing*/ | |
1639 src_params->curAtCmd = AT_CMD_P_CFIS; | |
1640 break; | |
1641 | |
1642 default: | |
1643 src_params->curAtCmd = AT_CMD_NONE; | |
1644 cmdCmeError(CME_ERR_Unknown); | |
1645 break; | |
1646 } | |
1647 return (map_aci_2_ati_rslt (ret)); | |
1648 } | |
1649 | |
1650 /* | |
1651 +--------------------------------------------------------------------+ | |
1652 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1653 | STATE : code ROUTINE : setatPercentMWIS | | |
1654 +--------------------------------------------------------------------+ | |
1655 | |
1656 PURPOSE : %MWIS command (Message Waiting Indication Status) | |
1657 */ | |
1658 | |
1659 GLOBAL T_ATI_RSLT setatPercentMWIS (char *cl, UBYTE srcId) | |
1660 { | |
1661 T_ACI_RETURN ret = AT_FAIL; | |
1662 T_ACI_MWIS_MOD mwisMode = MWIS_MOD_Invalid; | |
1663 UBYTE mspId = NOT_PRESENT_8BIT; | |
1664 T_ACI_MWIS_MWI mwis; | |
1665 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1666 | |
1667 TRACE_FUNCTION( "setatPercentMWIS()" ); | |
1668 | |
1669 memset(&mwis, 0, sizeof(T_ACI_MWIS_MWI)); | |
1670 cl = parse (cl, "ddddddd", &mwisMode, &mspId, &mwis.mwiStat, | |
1671 &mwis.mwis_count_voice, &mwis.mwis_count_fax, | |
1672 &mwis.mwis_count_email,&mwis.mwis_count_other); | |
1673 | |
1674 if(!cl) | |
1675 { | |
1676 cmdCmeError(CME_ERR_OpNotAllow); | |
1677 return (ATI_FAIL); | |
1678 } | |
1679 | |
1680 if( mwisMode EQ MWIS_MOD_Read) | |
1681 { | |
1682 ret = qAT_PercentMWIS(srcId, mspId ); | |
1683 } | |
1684 else | |
1685 { | |
1686 ret = sAT_PercentMWIS(srcId, mwisMode,mspId, &mwis); | |
1687 } | |
1688 | |
1689 switch (ret) | |
1690 { | |
1691 case AT_EXCT: /*Command is executing*/ | |
1692 src_params->curAtCmd = AT_CMD_P_MWIS; | |
1693 break; | |
1694 | |
1695 default: | |
1696 src_params->curAtCmd = AT_CMD_NONE; | |
1697 cmdCmeError(CME_ERR_Unknown); | |
1698 break; | |
1699 } | |
1700 return (map_aci_2_ati_rslt (ret)); | |
1701 } | |
1702 | |
1703 /* | |
1704 +--------------------------------------------------------------------+ | |
1705 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1706 | STATE : code ROUTINE : setatPercentMWI | | |
1707 +--------------------------------------------------------------------+ | |
1708 | |
1709 PURPOSE : %MWI command (Message Waiting Indication) | |
1710 */ | |
1711 | |
1712 GLOBAL T_ATI_RSLT setatPercentMWI(char *cl, UBYTE srcId) | |
1713 { | |
1714 SHORT mode = ACI_NumParmNotPresent; | |
1715 | |
1716 TRACE_FUNCTION("setatPercentMWI()"); | |
1717 | |
1718 cl = parse(cl,"r",&mode); | |
1719 if(!cl OR mode > 1 OR mode < 0) | |
1720 { | |
1721 cmdCmeError(CME_ERR_OpNotAllow); | |
1722 return (ATI_FAIL); | |
1723 } | |
1724 | |
1725 ati_user_output_cfg[srcId].MWI_stat=(UBYTE)mode; | |
1726 return (ATI_CMPL); | |
1727 } | |
1728 | |
1729 /* | |
1730 +--------------------------------------------------------------------+ | |
1731 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1732 | STATE : code ROUTINE : queatPercentMWI | | |
1733 +--------------------------------------------------------------------+ | |
1734 | |
1735 PURPOSE : %MWI command (Message Waiting Indication) | |
1736 */ | |
1737 | |
1738 GLOBAL T_ATI_RSLT queatPercentMWI(char *cl, UBYTE srcId) | |
1739 { | |
1740 UBYTE mode; | |
1741 | |
1742 TRACE_FUNCTION("queatPercentMWI()"); | |
1743 | |
1744 mode = ati_user_output_cfg[srcId].MWI_stat; | |
1745 resp_disp(srcId, cl,"b",&mode); | |
1746 return (ATI_CMPL); | |
1747 } | |
1748 | |
1749 | |
1750 /* | |
1751 +--------------------------------------------------------------------+ | |
1752 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1753 | STATE : code ROUTINE : setatPercentMBI | | |
1754 +--------------------------------------------------------------------+ | |
1755 | |
1756 PURPOSE : %MBI command (Mailbox Identifier) | |
1757 */ | |
1758 | |
1759 GLOBAL T_ATI_RSLT setatPercentMBI (char *cl, UBYTE srcId) | |
1760 { | |
1761 T_ACI_RETURN ret = AT_FAIL; | |
1762 T_ACI_MBN_MODE mbiMode = MBN_Mode_Invalid; | |
1763 UBYTE index = NOT_PRESENT_8BIT; | |
1764 | |
1765 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1766 | |
1767 TRACE_FUNCTION( "setatPercentMBI()" ); | |
1768 | |
1769 cl = parse (cl, "dd", &mbiMode, &index); | |
1770 | |
1771 if(!cl OR (mbiMode NEQ MBN_Mode_Read)) | |
1772 { | |
1773 cmdCmeError(CME_ERR_OpNotAllow); | |
1774 return (ATI_FAIL); | |
1775 } | |
1776 | |
1777 ret = qAT_PercentMBI(srcId, index ); | |
1778 | |
1779 switch (ret) | |
1780 { | |
1781 case AT_EXCT: /*Command is executing*/ | |
1782 src_params->curAtCmd = AT_CMD_P_MBI; | |
1783 break; | |
1784 | |
1785 default: | |
1786 src_params->curAtCmd = AT_CMD_NONE; | |
1787 cmdCmeError(CME_ERR_Unknown); | |
1788 break; | |
1789 } | |
1790 return (map_aci_2_ati_rslt (ret)); | |
1791 } | |
1792 /* | |
1793 +--------------------------------------------------------------------+ | |
1794 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1795 | STATE : code ROUTINE : setatPercentMBDN | | |
1796 +--------------------------------------------------------------------+ | |
1797 | |
1798 PURPOSE : %MBDN command (Mailbox Dialling Number) | |
1799 */ | |
1800 | |
1801 GLOBAL T_ATI_RSLT setatPercentMBDN (char *cl, UBYTE srcId) | |
1802 { | |
1803 T_ACI_RETURN ret = AT_FAIL; | |
1804 T_ACI_MBN_MODE mbdnMode = MBN_Mode_Invalid; | |
1805 UBYTE index = 0; | |
1806 CHAR number[MAX_MB_NUM_LEN]; | |
1807 CHAR alpha_id[MAX_ALPHA_LEN] = {0x00}; | |
1808 USHORT len_alpha_id = 0; | |
1809 USHORT lenCvtd = 0; /* holds length of converted text */ | |
1810 T_ACI_PB_TEXT *p_text = NULL; /* holds pointer to converted text */ | |
1811 T_ACI_PB_TEXT cvtdText; /* holds text converted to SIM alpha */ | |
1812 T_ACI_TOA type; | |
1813 T_ACI_TOA *p_type; | |
1814 CHAR *p_number; | |
1815 SHORT toa_oct = 0; | |
1816 UBYTE cc2_Id = NOT_PRESENT_8BIT; | |
1817 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1818 | |
1819 TRACE_FUNCTION( "setatPercentMBDN()" ); | |
1820 | |
1821 /* init */ | |
1822 memset( number, 0, sizeof(number)); | |
1823 | |
1824 cl = parse (cl, "ddsddz", &mbdnMode, &index,(LONG)MAX_MB_NUM_LEN, number, | |
1825 &toa_oct , &cc2_Id, (LONG)MAX_ALPHA_LEN, | |
1826 strlen(cl), cl, &len_alpha_id, alpha_id); | |
1827 | |
1828 if(!cl OR (mbdnMode < 0 OR mbdnMode > 2) OR (!index)) | |
1829 { | |
1830 cmdCmeError(CME_ERR_OpNotAllow); | |
1831 return (ATI_FAIL); | |
1832 } | |
1833 | |
1834 /* translate alpha text to SIM */ | |
1835 if ( len_alpha_id NEQ 0 ) | |
1836 { | |
1837 utl_chsetToSim ((UBYTE*)alpha_id, len_alpha_id, (UBYTE*)cvtdText.data, | |
1838 &lenCvtd, GSM_ALPHA_Def); | |
1839 } | |
1840 | |
1841 if (toa_oct EQ 0) | |
1842 { | |
1843 p_type = NULL; | |
1844 } | |
1845 else | |
1846 { | |
1847 type=toa_demerge(toa_oct); | |
1848 p_type = &type; | |
1849 } | |
1850 | |
1851 /* when the text is empty p_text to NULL */ | |
1852 if (lenCvtd EQ 0 ) | |
1853 { | |
1854 p_text = NULL; | |
1855 } | |
1856 else | |
1857 { | |
1858 p_text = &cvtdText; | |
1859 cvtdText.len = (UBYTE)lenCvtd; | |
1860 } | |
1861 | |
1862 /* set pointer for number */ | |
1863 if (number[0] EQ '\0') /* The number given is empty */ | |
1864 { | |
1865 p_number = NULL; | |
1866 } | |
1867 else | |
1868 { | |
1869 p_number = number; | |
1870 } | |
1871 | |
1872 if( mbdnMode EQ MBN_Mode_Read) | |
1873 { | |
1874 ret = qAT_PercentMBDN(srcId, index ); | |
1875 } | |
1876 else | |
1877 { | |
1878 ret = sAT_PercentMBDN(srcId, mbdnMode,index, | |
1879 p_number, p_type, cc2_Id, p_text); | |
1880 } | |
1881 | |
1882 switch (ret) | |
1883 { | |
1884 case AT_EXCT: /*Command is executing*/ | |
1885 src_params->curAtCmd = AT_CMD_P_MBDN; | |
1886 break; | |
1887 | |
1888 default: | |
1889 src_params->curAtCmd = AT_CMD_NONE; | |
1890 cmdCmeError(CME_ERR_Unknown); | |
1891 break; | |
1892 } | |
1893 return (map_aci_2_ati_rslt (ret)); | |
1894 } | |
1895 #endif /* FF_CPHS_REL4 */ | |
1896 | |
1897 #endif /* ATI_SIM_C */ |