FreeCalypso > hg > freecalypso-citrine
comparison g23m-aci/aci/ati_phb.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 commands related to phonebook. | |
18 +----------------------------------------------------------------------------- | |
19 */ | |
20 | |
21 #ifndef ATI_PHB_C | |
22 #define ATI_PHB_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 #include "phb.h" | |
40 | |
41 #ifdef FAX_AND_DATA | |
42 #include "aci_fd.h" | |
43 #endif /* of #ifdef FAX_AND_DATA */ | |
44 | |
45 #include "aci_mem.h" | |
46 #include "psa.h" | |
47 #include "cmh.h" | |
48 #include "pcm.h" | |
49 #include "aci_prs.h" | |
50 | |
51 #include "ati_int.h" | |
52 | |
53 #ifdef FF_ATI_BAT | |
54 | |
55 #include "typedefs.h" | |
56 #include "gdd.h" | |
57 #include "bat.h" | |
58 | |
59 #include "ati_bat.h" | |
60 | |
61 #endif /* FF_ATI_BAT */ | |
62 | |
63 /* Global variables for reading PHB entries */ | |
64 LOCAL SHORT phb_start_idx, phb_stop_idx; | |
65 | |
66 /* | |
67 +--------------------------------------------------------------------+ | |
68 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
69 | STATE : code ROUTINE : atPlusCPBS | | |
70 +--------------------------------------------------------------------+ | |
71 | |
72 PURPOSE : +CPBS (Select Phonebook memory storage) | |
73 */ | |
74 | |
75 GLOBAL T_ATI_RSLT setatPlusCPBS(char *cl, UBYTE srcId) | |
76 { | |
77 T_ACI_RETURN ret = AT_FAIL; | |
78 T_ACI_PB_STOR stor = PB_STOR_NotPresent; | |
79 CHAR pin2[MAX_PWD_LENGTH] = {0}; | |
80 CHAR sto_str[3]={0}; | |
81 SHORT i; | |
82 | |
83 TRACE_FUNCTION("setatPlusCPBS()"); | |
84 | |
85 cl = parse(cl,"sn",(LONG)3,sto_str,(LONG)MAX_PWD_LENGTH,pin2); | |
86 if(!cl OR *sto_str EQ '\0') | |
87 { | |
88 cmdCmeError(CME_ERR_OpNotAllow); | |
89 return ATI_FAIL; | |
90 } | |
91 strupper(sto_str); | |
92 for(i=0;phb_mem_names[i].name NEQ 0;i++) | |
93 { | |
94 if (!strcmp(phb_mem_names[i].name,sto_str) ) | |
95 { | |
96 stor=phb_mem_names[i].stor; | |
97 break; | |
98 } | |
99 } | |
100 if(phb_mem_names[i].name EQ 0) | |
101 { | |
102 cmdCmeError(CME_ERR_OpNotAllow); | |
103 return ATI_FAIL; | |
104 } | |
105 #ifdef FF_ATI_BAT | |
106 { | |
107 T_BAT_cmd_send cmd; | |
108 T_BAT_cmd_set_plus_cpbs my_bat_set_plus_cpbs = {0}; | |
109 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
110 | |
111 TRACE_FUNCTION("setatPlusCPBS() calls bat_send() <=== as APPLICATION"); | |
112 | |
113 cmd.ctrl_params = BAT_CMD_SET_PLUS_CPBS; | |
114 cmd.params.ptr_set_plus_cpbs = &my_bat_set_plus_cpbs; | |
115 | |
116 my_bat_set_plus_cpbs.storage = (T_BAT_storage)stor; | |
117 | |
118 src_params->curAtCmd = AT_CMD_CPBS; | |
119 srcId_cb = srcId; | |
120 bat_send(ati_bat_get_client(srcId), &cmd); | |
121 srcId_cb = srcId; | |
122 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
123 } | |
124 #else /* no FF_ATI_BAT */ | |
125 ret = sAT_PlusCPBS((T_ACI_CMD_SRC)srcId,stor,pin2); | |
126 if (ret EQ AT_FAIL) | |
127 { | |
128 cmdCmeError(CME_ERR_Unknown); | |
129 } | |
130 | |
131 return (map_aci_2_ati_rslt(ret)); | |
132 #endif /* no FF_ATI_BAT */ | |
133 } | |
134 | |
135 | |
136 GLOBAL T_ATI_RSLT queatPlusCPBS(char *cl, UBYTE srcId) | |
137 { | |
138 #ifdef FF_ATI_BAT | |
139 { | |
140 T_BAT_cmd_send cmd; | |
141 T_BAT_no_parameter dummy; | |
142 | |
143 TRACE_FUNCTION("queatPlusCPBS() calls bat_send() <=== as APPLICATION"); | |
144 | |
145 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CPBS; | |
146 dummy.bat_dummy = 0xFF; | |
147 cmd.params.ptr_que_plus_cpbs = &dummy; | |
148 bat_send(ati_bat_get_client(srcId), &cmd); | |
149 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
150 } | |
151 #else /* no FF_ATI_BAT */ | |
152 | |
153 T_ACI_RETURN ret = AT_FAIL; | |
154 T_ACI_PB_STOR stor; | |
155 SHORT used; | |
156 SHORT total; | |
157 SHORT i; | |
158 | |
159 TRACE_FUNCTION("queatPlusCPBS()"); | |
160 | |
161 ret = qAT_PlusCPBS((T_ACI_CMD_SRC)srcId,&stor,&used,&total); | |
162 if (ret EQ AT_CMPL) | |
163 { | |
164 for(i=0;phb_mem_names[i].name NEQ NULL;i++) | |
165 { | |
166 if (phb_mem_names[i].stor EQ stor) | |
167 { | |
168 sprintf(g_sa,"+CPBS: \"%s\",%d,%d",phb_mem_names[i].name,used,total); | |
169 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
170 break; | |
171 } | |
172 } | |
173 } | |
174 else if (ret EQ AT_FAIL) | |
175 { | |
176 cmdCmeError(CME_ERR_Unknown); | |
177 } | |
178 return (map_aci_2_ati_rslt(ret)); | |
179 #endif /* no FF_ATI_BAT */ | |
180 } | |
181 | |
182 /* | |
183 +--------------------------------------------------------------------+ | |
184 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
185 | STATE : code ROUTINE : queatPercentCPBS | | |
186 +--------------------------------------------------------------------+ | |
187 | |
188 PURPOSE : %CPBS (Phonebook memory storage) | |
189 */ | |
190 GLOBAL T_ATI_RSLT queatPercentCPBS(char *cl, UBYTE srcId) | |
191 { | |
192 #ifdef FF_ATI_BAT | |
193 | |
194 T_BAT_cmd_send cmd; | |
195 T_BAT_no_parameter dummy; | |
196 | |
197 TRACE_FUNCTION("queatPercentCPBS() calls bat_send() <=== as APPLICATION"); | |
198 | |
199 cmd.ctrl_params=BAT_CMD_QUE_PERCENT_CPBS; | |
200 dummy.bat_dummy=0xFF; | |
201 cmd.params.ptr_que_percent_cpbs=&dummy; | |
202 | |
203 bat_send(ati_bat_get_client(srcId),&cmd); | |
204 | |
205 /* | |
206 * Return value indicates executing, the response will come via | |
207 * the callback function. | |
208 */ | |
209 return(ATI_EXCT); | |
210 | |
211 #else /* FF_ATI_BAT */ | |
212 | |
213 char *me="%CPBS: "; | |
214 T_ACI_RETURN ret; | |
215 T_ACI_PB_STOR stor; | |
216 SHORT used,total,first,i; | |
217 SHORT used_ext, total_ext; | |
218 | |
219 TRACE_FUNCTION("queatPercentCPBS()"); | |
220 | |
221 /* | |
222 * Call the corresponding ACI function. | |
223 */ | |
224 ret=qAT_PercentCPBS ((T_ACI_CMD_SRC)srcId, | |
225 &stor, | |
226 &used, &total, | |
227 &first, | |
228 &used_ext, &total_ext); | |
229 | |
230 /* | |
231 * If the query completes successfully, build and send the | |
232 * answer. | |
233 */ | |
234 if (ret EQ AT_CMPL) | |
235 { | |
236 /* | |
237 * Run through the list of names to get the name of the | |
238 * currently selected phonebook. | |
239 */ | |
240 for(i=0;phb_mem_names[i].name NEQ NULL;i++) | |
241 { | |
242 if (phb_mem_names[i].stor EQ stor) | |
243 { | |
244 sprintf (g_sa,"%s\"%s\",%d,%d,%d,%d,%d", me, phb_mem_names[i].name, | |
245 used, total, | |
246 first, | |
247 used_ext, total_ext); | |
248 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
249 break; | |
250 } | |
251 } | |
252 } | |
253 | |
254 return (map_aci_2_ati_rslt(ret)); | |
255 | |
256 #endif /* FF_ATI_BAT */ | |
257 } | |
258 | |
259 /* | |
260 +--------------------------------------------------------------------+ | |
261 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
262 | STATE : code ROUTINE : atPlusCPBW | | |
263 +--------------------------------------------------------------------+ | |
264 | |
265 PURPOSE : +CPBW (Write Phonebook entry) | |
266 */ | |
267 GLOBAL T_ATI_RSLT setatPlusCPBW(char *cl, UBYTE srcId) | |
268 { | |
269 | |
270 UBYTE pb_status; | |
271 T_ACI_RETURN ret = AT_FAIL; | |
272 CHAR *p_number = NULL; | |
273 CHAR text [MAX_ALPHA_LEN * 4] = {0x00}; | |
274 USHORT lenText = 0; | |
275 T_ACI_TOA *p_toa = NULL, | |
276 type; | |
277 | |
278 SHORT toa_val = 0, | |
279 index = -1; | |
280 #ifndef FF_ATI_BAT | |
281 T_ACI_PB_TEXT *p_text = NULL; | |
282 T_ACI_PB_TEXT cvtdText; | |
283 USHORT lenCvtd = 0; | |
284 T_ACI_VP_ABS dmyDateTime; | |
285 #endif /* !FF_ATI_BAT */ | |
286 | |
287 T_ACI_PB_STOR stor; | |
288 SHORT used; | |
289 SHORT total; | |
290 CHAR numBuf[MAX_PHB_NUM_LEN]; | |
291 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
292 | |
293 memset( numBuf, 0, sizeof(numBuf)); | |
294 | |
295 TRACE_FUNCTION("setatPlusCPBW()"); | |
296 | |
297 | |
298 ret = qAT_PlusCPBS((T_ACI_CMD_SRC)srcId,&stor,&used,&total); | |
299 TRACE_EVENT_P1("Current phonebook storage: %d", stor); | |
300 | |
301 #ifdef TI_PS_FFS_PHB | |
302 if (ret EQ AT_FAIL) | |
303 { | |
304 cmdCmeError(CME_ERR_Unknown); | |
305 return ATI_FAIL; | |
306 } | |
307 #endif | |
308 | |
309 if (ret EQ AT_CMPL AND | |
310 stor EQ PB_STOR_Ed) | |
311 { | |
312 cmdCmeError(CME_ERR_OpNotAllow); | |
313 return ATI_FAIL; | |
314 } | |
315 | |
316 if ( ati_user_output_cfg[srcId].cscsChset EQ CSCS_CHSET_Gsm) | |
317 { | |
318 cl=parse(cl,"rsrz", | |
319 &index, | |
320 (LONG)MAX_PHB_NUM_LEN, | |
321 numBuf, | |
322 &toa_val, | |
323 (LONG)MAX_ALPHA_LEN, | |
324 strlen(cl), | |
325 cl, | |
326 &lenText, | |
327 text); | |
328 } | |
329 else | |
330 { | |
331 cl=parse(cl,"rsrz", | |
332 &index, | |
333 (LONG)MAX_PHB_NUM_LEN, | |
334 numBuf, | |
335 &toa_val, | |
336 (LONG)MAX_ALPHA_LEN * 4, | |
337 strlen(cl), | |
338 cl, | |
339 &lenText, | |
340 text); | |
341 } | |
342 | |
343 if(!cl) | |
344 { | |
345 TRACE_ERROR("ERROR: parsing failed !!!"); | |
346 index = get_parse_index(); /* get the problematic component */ | |
347 switch (index) | |
348 { | |
349 case 2: /* component 2 is the number */ | |
350 cmdCmeError(CME_ERR_DialToLong); | |
351 break; | |
352 case 4: /* component 4 is the alpha tag */ | |
353 cmdCmeError(CME_ERR_TxtToLong); | |
354 break; | |
355 default: | |
356 cmdCmeError(CME_ERR_OpNotAllow); | |
357 break; | |
358 } | |
359 return ATI_FAIL; | |
360 } | |
361 | |
362 /* If the phonebook status is not PHB_READY then SIM BUSY error is indicated to the user.*/ | |
363 pb_status_req(&pb_status); /* get phone book status */ | |
364 | |
365 TRACE_EVENT_P1("Current phonebook status: %d", pb_status); | |
366 if (pb_status NEQ PHB_READY) | |
367 { | |
368 if(pb_status EQ PHB_BUSY) | |
369 { | |
370 TRACE_EVENT("Error: Phonebook is busy accessing the SIM"); | |
371 cmdCmeError(CME_ERR_SimBusy); | |
372 } | |
373 else if(pb_status EQ PHB_UNKNOWN) | |
374 { | |
375 TRACE_EVENT("Error: Phonebook status unknown"); | |
376 cmdCmeError(CME_ERR_Unknown); | |
377 } | |
378 return ATI_FAIL; | |
379 } | |
380 | |
381 if( index > total) /* phonebook index is greater than max. */ | |
382 { /* possible index of SIM */ | |
383 TRACE_EVENT("Error: phonebook index is greater than max possible index of SIM"); | |
384 cmdCmeError(CME_ERR_InvIdx); | |
385 return ATI_FAIL; | |
386 } | |
387 | |
388 if (toa_val > 0) | |
389 { | |
390 type=toa_demerge(toa_val); | |
391 p_toa=&type; | |
392 } | |
393 else | |
394 p_toa=NULL; | |
395 | |
396 if (numBuf[0] EQ '\0') | |
397 p_number=NULL; | |
398 else | |
399 p_number=numBuf; | |
400 | |
401 #ifdef FF_ATI_BAT | |
402 { | |
403 T_BAT_cmd_send cmd; | |
404 T_BAT_cmd_set_plus_cpbw my_bat_set_plus_cpbw = {0}; | |
405 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
406 | |
407 TRACE_FUNCTION("setatPlusCPBW() calls bat_send() <=== as APPLICATION"); | |
408 | |
409 cmd.ctrl_params = BAT_CMD_SET_PLUS_CPBW; | |
410 cmd.params.ptr_set_plus_cpbw = &my_bat_set_plus_cpbw; | |
411 | |
412 my_bat_set_plus_cpbw.index = (S16)index; | |
413 | |
414 /* Load the phone number in BAT struct - if there is one */ | |
415 if (p_number) | |
416 { | |
417 if (strlen(p_number)>BAT_MAX_CPBW_NUMBER_LEN) | |
418 { | |
419 /* | |
420 * If the number is too big for the BAT structure we can't do | |
421 * anything meaningful, so get out now. | |
422 */ | |
423 cmdCmeError(CME_ERR_Unknown); | |
424 return ATI_FAIL; | |
425 } | |
426 | |
427 my_bat_set_plus_cpbw.c_number = strlen(p_number); | |
428 my_bat_set_plus_cpbw.v_number = TRUE; | |
429 memcpy(my_bat_set_plus_cpbw.number, p_number,BAT_MAX_CPBW_NUMBER_LEN); | |
430 } | |
431 else | |
432 { | |
433 my_bat_set_plus_cpbw.v_number = FALSE; | |
434 } | |
435 | |
436 /* | |
437 * Load the associated text in BAT struct - if there is any | |
438 */ | |
439 if ((lenText EQ 0) AND (p_number EQ NULL)) | |
440 { | |
441 my_bat_set_plus_cpbw.v_text = FALSE; | |
442 } | |
443 else | |
444 { | |
445 /* | |
446 * If the associated text is too big for the BAT structure it | |
447 * will be truncated. | |
448 */ | |
449 if (lenText>BAT_MAX_CPBW_TEXT_LEN) | |
450 my_bat_set_plus_cpbw.c_text = BAT_MAX_CPBW_TEXT_LEN; | |
451 else | |
452 my_bat_set_plus_cpbw.c_text = (U8)lenText; | |
453 | |
454 my_bat_set_plus_cpbw.v_text = TRUE; | |
455 memcpy(my_bat_set_plus_cpbw.text, text, BAT_MAX_CPBW_TEXT_LEN); | |
456 } | |
457 | |
458 /* Load type as string input */ | |
459 if (p_toa) | |
460 my_bat_set_plus_cpbw.type = (S16)toa_val; | |
461 else | |
462 my_bat_set_plus_cpbw.type = (S16)-1; | |
463 | |
464 src_params->curAtCmd = AT_CMD_CPBW; | |
465 srcId_cb = srcId; | |
466 bat_send(ati_bat_get_client(srcId), &cmd); | |
467 | |
468 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
469 } | |
470 | |
471 #else /* no FF_ATI_BAT */ | |
472 | |
473 if( lenText NEQ 0 ) | |
474 { | |
475 srcId_cb = srcId; | |
476 utl_chsetToSim ((UBYTE*)text, lenText, (UBYTE*)cvtdText.data, | |
477 &lenCvtd, GSM_ALPHA_Def); | |
478 } | |
479 cvtdText.cs = CS_Sim; | |
480 | |
481 /* when the text and the number are both empty, set p_text to NULL */ | |
482 if (lenCvtd EQ 0 AND p_number EQ NULL) | |
483 { | |
484 p_text = NULL; | |
485 } | |
486 else | |
487 { | |
488 p_text = &cvtdText; | |
489 cvtdText.len = (UBYTE)lenCvtd; | |
490 } | |
491 | |
492 ret = sAT_PlusCPBW((T_ACI_CMD_SRC)srcId, index, p_number, p_toa, p_text, &dmyDateTime); | |
493 switch (ret) | |
494 { | |
495 case AT_FAIL: | |
496 switch (ACI_ERR_DESC_CLASS( aciErrDesc )) | |
497 { | |
498 case ACI_ERR_CLASS_Cme: | |
499 cmdCmeError( (T_ACI_CME_ERR)ACI_ERR_DESC_NR( aciErrDesc ) ); | |
500 break; | |
501 case ACI_ERR_CLASS_Cms: | |
502 case ACI_ERR_CLASS_Ceer: | |
503 case ACI_ERR_CLASS_Ext: | |
504 default: | |
505 cmdCmeError(CME_ERR_Unknown); | |
506 break; | |
507 } | |
508 break; | |
509 case AT_EXCT: | |
510 src_params->curAtCmd = AT_CMD_CPBW; | |
511 break; | |
512 | |
513 case AT_BUSY: | |
514 cmdCmeError(CME_ERR_SimBusy); | |
515 break; | |
516 } | |
517 return (map_aci_2_ati_rslt(ret)); | |
518 #endif /* no FF_ATI_BAT */ | |
519 } | |
520 | |
521 GLOBAL T_ATI_RSLT tesatPlusCPBW(char *cl, UBYTE srcId) | |
522 { | |
523 #ifdef FF_ATI_BAT | |
524 | |
525 T_BAT_cmd_send cmd; | |
526 T_BAT_no_parameter dummy; | |
527 | |
528 TRACE_FUNCTION("queatPlusCPBW() calls bat_send() <=== as APPLICATION"); | |
529 | |
530 cmd.ctrl_params = BAT_CMD_TST_PLUS_CPBW; | |
531 dummy.bat_dummy = 0xFF; | |
532 cmd.params.ptr_tst_plus_cpbw = &dummy; | |
533 | |
534 bat_send(ati_bat_get_client(srcId), &cmd); | |
535 | |
536 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
537 | |
538 #else /* no FF_ATI_BAT */ | |
539 | |
540 char *me = "+CPBW: "; | |
541 T_ACI_RETURN ret = AT_FAIL; | |
542 | |
543 SHORT first_idx, | |
544 last_idx; | |
545 UBYTE nlength, | |
546 tlength; | |
547 CHAR numBuf[MAX_PHB_NUM_LEN]; | |
548 | |
549 memset( numBuf, 0, sizeof(numBuf)); | |
550 | |
551 TRACE_FUNCTION("tesatPlusCPBW()"); | |
552 | |
553 ret = tAT_PlusCPBW((T_ACI_CMD_SRC)srcId,&first_idx,&last_idx,&nlength,&tlength); | |
554 if(ret EQ AT_CMPL) | |
555 { | |
556 sprintf(g_sa,"%s(%d-%d),%d,%s,%d",me,first_idx,last_idx,nlength,"(128-201)",tlength); | |
557 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
558 } | |
559 else | |
560 { | |
561 cmdCmeError(CME_ERR_Unknown); | |
562 } | |
563 return (map_aci_2_ati_rslt(ret)); | |
564 #endif /* no FF_ATI_BAT */ | |
565 } | |
566 | |
567 /* | |
568 +-------------------------------------------------------------------+ | |
569 | PROJECT : GSM-PS (6147) MODULE : ACI_CMD | | |
570 | STATE : code ROUTINE : cmd_readCPBRBlock | | |
571 +-------------------------------------------------------------------+ | |
572 | |
573 PURPOSE : This is the functional counterpart of the +CPBR | |
574 AT command which is responsible for reading phonebook | |
575 entries from memory, 5 at a time. | |
576 | |
577 */ | |
578 GLOBAL T_ACI_RETURN cmd_readCPBRBlock ( UBYTE srcId) | |
579 { | |
580 CHAR cvtdText[4*MAX_ALPHA_LEN] = {0x00}; /* need enough space for UCS2 strings */ | |
581 USHORT lenCvtdText = 0; | |
582 USHORT pos = 0; | |
583 SHORT last_idx = ACI_NumParmNotPresent; | |
584 SHORT i; | |
585 T_ACI_PB_LST pblst; | |
586 UBYTE type; | |
587 T_ACI_RETURN ret = AT_FAIL; | |
588 | |
589 TRACE_FUNCTION ("cmd_readCPBRBlock ()"); | |
590 | |
591 ret = sAT_PlusCPBR((T_ACI_CMD_SRC) srcId,phb_start_idx,phb_stop_idx,&last_idx,pblst); | |
592 | |
593 if (ret EQ AT_CMPL) | |
594 { | |
595 for ( i = 0; | |
596 i < MAX_PB_ENTR; | |
597 i++ ) | |
598 { | |
599 if(pblst[i].index EQ ACI_NumParmNotPresent) | |
600 { | |
601 break; /* All entries are read */ | |
602 } | |
603 | |
604 type = toa_merge(pblst[i].type); | |
605 | |
606 pos=sprintf(g_sa,"+CPBR: %d,\"%s\",%d,", | |
607 pblst[i].index, | |
608 pblst[i].number, | |
609 type); | |
610 | |
611 srcId_cb = srcId; | |
612 utl_chsetFromSim((UBYTE*)pblst[i].text.data, | |
613 pblst[i].text.len, | |
614 (UBYTE*)cvtdText, | |
615 sizeof(cvtdText), | |
616 &lenCvtdText, | |
617 GSM_ALPHA_Def); | |
618 | |
619 pos+=sprints(g_sa+pos,cvtdText,lenCvtdText); | |
620 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
621 } | |
622 | |
623 phb_start_idx = last_idx; | |
624 | |
625 /* To read next entry */ | |
626 phb_start_idx++; | |
627 | |
628 if(phb_start_idx EQ (phb_stop_idx + 1)) | |
629 { | |
630 return AT_CMPL; | |
631 } | |
632 else | |
633 { | |
634 /* Still entries to read */ | |
635 return AT_EXCT; | |
636 } | |
637 } | |
638 else | |
639 { | |
640 cmdCmeError(CME_ERR_Unknown); | |
641 return AT_FAIL; | |
642 } | |
643 } | |
644 | |
645 /* | |
646 +-------------------------------------------------------------------+ | |
647 | PROJECT : GSM-PS (6147) MODULE : ACI_CMD | | |
648 | STATE : code ROUTINE : cmd_PlusCPBR_CB | | |
649 +-------------------------------------------------------------------+ | |
650 | |
651 PURPOSE : This is the functional counterpart of the +CPBR | |
652 AT command which is responsible for reading phonebook | |
653 entries from memory. | |
654 | |
655 This is a callback function for reading remaining | |
656 phonebook entries called from sap_dti.c. | |
657 This function reads 5 entries from where the last | |
658 reading had stopped. | |
659 */ | |
660 GLOBAL void cmd_PlusCPBR_CB ( UBYTE srcId) | |
661 { | |
662 T_ACI_RETURN ret; | |
663 | |
664 TRACE_FUNCTION ("cmd_PlusCPBR_CB()"); | |
665 | |
666 /* Call cmd_readCPBRBlock() | |
667 when still entries are to be read */ | |
668 if(phb_stop_idx >= phb_start_idx) | |
669 { | |
670 ret = cmd_readCPBRBlock(srcId); | |
671 | |
672 switch(ret) | |
673 { | |
674 case AT_EXCT: | |
675 /* Still entries to read */ | |
676 return; | |
677 | |
678 case AT_CMPL: | |
679 /* All the entries are read */ | |
680 R_AT( RAT_OK, (T_ACI_CMD_SRC) srcId ) | |
681 (AT_CMD_CPBR); | |
682 break; | |
683 | |
684 default: | |
685 /* Failed to read entries */ | |
686 R_AT( RAT_CME, (T_ACI_CMD_SRC) srcId ) | |
687 ( AT_CMD_CPBR, CME_ERR_Unknown); | |
688 } | |
689 } | |
690 } | |
691 /* | |
692 +--------------------------------------------------------------------+ | |
693 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
694 | STATE : code ROUTINE : atPlusCPBR | | |
695 +--------------------------------------------------------------------+ | |
696 | |
697 PURPOSE : +CPBR (Read Phonebook Entry) | |
698 */ | |
699 | |
700 GLOBAL T_ATI_RSLT setatPlusCPBR(char *cl, UBYTE srcId) | |
701 { | |
702 T_ACI_RETURN ret; | |
703 | |
704 TRACE_FUNCTION("setatPlusCPBR()"); | |
705 | |
706 phb_start_idx = ACI_NumParmNotPresent; | |
707 phb_stop_idx = ACI_NumParmNotPresent; | |
708 | |
709 cl = parse(cl,"rr",&phb_start_idx,&phb_stop_idx); | |
710 if(!cl OR phb_start_idx > MAX_PB_INDEX OR phb_start_idx < 0 OR phb_stop_idx > MAX_PB_INDEX) | |
711 { | |
712 cmdCmeError(CME_ERR_OpNotAllow); | |
713 return ATI_FAIL; | |
714 } | |
715 if(phb_stop_idx EQ ACI_NumParmNotPresent) | |
716 { | |
717 phb_stop_idx=phb_start_idx; | |
718 } | |
719 | |
720 #ifdef FF_ATI_BAT | |
721 { | |
722 T_BAT_cmd_send cmd; | |
723 T_BAT_cmd_set_plus_cpbr my_bat_set_plus_cpbr = {0}; | |
724 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
725 | |
726 TRACE_FUNCTION("setatPlusCPBR() calls bat_send() <=== as APPLICATION"); | |
727 | |
728 cmd.ctrl_params = BAT_CMD_SET_PLUS_CPBR; | |
729 cmd.params.ptr_set_plus_cpbr = &my_bat_set_plus_cpbr; | |
730 | |
731 my_bat_set_plus_cpbr.index1 = (U8) phb_start_idx; | |
732 my_bat_set_plus_cpbr.index2 = (S16) phb_stop_idx; | |
733 | |
734 src_params->curAtCmd = AT_CMD_CPBR; | |
735 srcId_cb = srcId; | |
736 bat_send(ati_bat_get_client(srcId), &cmd); | |
737 | |
738 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
739 } | |
740 #else /* no FF_ATI_BAT */ | |
741 | |
742 /* Read 5 entries at a time */ | |
743 ret = cmd_readCPBRBlock(srcId); | |
744 | |
745 #endif /* no FF_ATI_BAT */ | |
746 | |
747 return (map_aci_2_ati_rslt(ret)); | |
748 } | |
749 | |
750 GLOBAL T_ATI_RSLT tesatPlusCPBR(char *cl, UBYTE srcId) | |
751 { | |
752 #ifdef FF_ATI_BAT | |
753 | |
754 T_BAT_cmd_send cmd; | |
755 T_BAT_no_parameter dummy; | |
756 | |
757 TRACE_FUNCTION("tesatPlusCPBR() calls bat_send() <=== as APPLICATION"); | |
758 | |
759 cmd.ctrl_params = BAT_CMD_TST_PLUS_CPBR; | |
760 dummy.bat_dummy = 0xFF; | |
761 cmd.params.ptr_tst_plus_cpbr = &dummy; | |
762 | |
763 bat_send(ati_bat_get_client(srcId), &cmd); | |
764 | |
765 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
766 | |
767 #else /* no FF_ATI_BAT */ | |
768 | |
769 T_ACI_RETURN ret = AT_FAIL; | |
770 SHORT first_idx, | |
771 last_idx = ACI_NumParmNotPresent; | |
772 UBYTE nlength, | |
773 tlength; | |
774 | |
775 TRACE_FUNCTION("tesatPlusCPBR()"); | |
776 | |
777 ret = tAT_PlusCPBR((T_ACI_CMD_SRC)srcId,&first_idx,&last_idx,&nlength,&tlength); | |
778 if(ret EQ AT_CMPL) | |
779 { | |
780 sprintf(g_sa,"+CPBR: (%d-%d),%d,%d",first_idx,last_idx,nlength,tlength); | |
781 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
782 } | |
783 else | |
784 { | |
785 cmdCmeError(CME_ERR_Unknown); | |
786 } | |
787 return (map_aci_2_ati_rslt(ret)); | |
788 | |
789 #endif /* no FF_ATI_BAT */ | |
790 } | |
791 | |
792 /* | |
793 +--------------------------------------------------------------------+ | |
794 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
795 | STATE : code ROUTINE : atPlusCPBF | | |
796 +--------------------------------------------------------------------+ | |
797 | |
798 PURPOSE : +CPBF (Find Text in Phonebook) | |
799 */ | |
800 | |
801 GLOBAL T_ATI_RSLT setatPlusCPBF(char *cl, UBYTE srcId) | |
802 { | |
803 #ifndef FF_ATI_BAT | |
804 T_ACI_RETURN ret = AT_FAIL; | |
805 #ifndef NO_ASCIIZ | |
806 CHAR cvtdFindstr[MAX_ALPHA_LEN] = {0x00}; | |
807 #endif | |
808 USHORT lenCvtdFindstr = 0; | |
809 CHAR cvtdText [2*MAX_ALPHA_LEN] = {0x00}; | |
810 USHORT lenCvtdText = 0; | |
811 USHORT pos = 0; | |
812 | |
813 SHORT i, | |
814 j; | |
815 SHORT found; | |
816 T_ACI_PB_LST pblst; | |
817 UBYTE type; | |
818 | |
819 #ifdef NO_ASCIIZ | |
820 T_ACI_PB_TEXT pbText; | |
821 #endif /* #ifdef NO_ASCIIZ */ | |
822 | |
823 #endif /* FF_ATI_BAT */ | |
824 | |
825 CHAR findstr [MAX_ALPHA_LEN] = {0x00}; | |
826 USHORT lenFindstr = 0; | |
827 | |
828 TRACE_FUNCTION("setatPlusCPBF()"); | |
829 | |
830 cl=parse(cl,"z", | |
831 (LONG)MAX_ALPHA_LEN, | |
832 strlen(cl), | |
833 cl, | |
834 &lenFindstr, | |
835 findstr); | |
836 if(!cl OR lenFindstr EQ 0) | |
837 { | |
838 cmdCmeError(CME_ERR_OpNotAllow); | |
839 return ATI_FAIL; | |
840 } | |
841 srcId_cb = srcId; | |
842 | |
843 #ifdef FF_ATI_BAT | |
844 { | |
845 T_BAT_cmd_send cmd; | |
846 T_BAT_cmd_set_plus_cpbf cpbf; | |
847 | |
848 cmd.ctrl_params = BAT_CMD_SET_PLUS_CPBF; | |
849 cmd.params.ptr_set_plus_cpbf=&cpbf; | |
850 | |
851 /* | |
852 * Check that the string isn't too long for the BAT message. | |
853 */ | |
854 if (lenFindstr>BAT_MAX_CPBF_FIND_TEXT_LEN) | |
855 { | |
856 cmdCmeError(CME_ERR_Unknown); | |
857 return ATI_FAIL; | |
858 } | |
859 | |
860 cpbf.c_findtext=(U8)lenFindstr; | |
861 memcpy(cpbf.findtext,findstr,lenFindstr); | |
862 | |
863 bat_send(ati_bat_get_client(srcId), &cmd); | |
864 return(ATI_EXCT); | |
865 } | |
866 #else /* no FF_ATI_BAT */ | |
867 | |
868 #ifdef NO_ASCIIZ | |
869 utl_chsetToSim ( (UBYTE*)findstr, | |
870 lenFindstr, | |
871 pbText.data, | |
872 &lenCvtdFindstr, | |
873 GSM_ALPHA_Def ); | |
874 | |
875 pbText.cs = CS_Sim; | |
876 pbText.len = (UBYTE)lenCvtdFindstr; | |
877 | |
878 ret = sAT_PlusCPBF( (T_ACI_CMD_SRC)srcId, &pbText, CPBF_MOD_NewSearch, | |
879 &found, &pblst[0] ); | |
880 #else /* #ifdef NO_ASCIIZ */ | |
881 utl_chsetToGsm ( (UBYTE*)findstr, | |
882 lenFindstr, | |
883 (UBYTE*)cvtdFindstr, | |
884 &lenCvtdFindstr, | |
885 #ifdef REL99 | |
886 sizeof(cvtdFindstr), | |
887 #endif /* REL99 */ | |
888 GSM_ALPHA_Int ); | |
889 | |
890 ret = sAT_PlusCPBF( srcId, cvtdFindstr, CPBF_MOD_NewSearch, | |
891 &found, &pblst[0] ); | |
892 #endif /* #ifdef NO_ASCIIZ */ | |
893 if (ret EQ AT_CMPL) | |
894 { | |
895 i=0; | |
896 while(i<MAX_PB_ENTR AND i < found) | |
897 { | |
898 type = toa_merge(pblst[i].type); | |
899 | |
900 pos=sprintf(g_sa,"+CPBF: %d,\"%s\",%d,", | |
901 pblst[i].index, | |
902 pblst[i].number, | |
903 type); | |
904 utl_chsetFromSim((UBYTE*)pblst[i].text.data, | |
905 pblst[i].text.len, | |
906 (UBYTE*)cvtdText, | |
907 sizeof(cvtdText), | |
908 &lenCvtdText, | |
909 GSM_ALPHA_Def); | |
910 pos+=sprints(g_sa+pos,cvtdText,lenCvtdText); | |
911 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
912 i++; | |
913 } | |
914 if (found > MAX_PB_ENTR) | |
915 { | |
916 while(i < found) | |
917 { | |
918 #ifdef NO_ASCIIZ | |
919 ret = sAT_PlusCPBF( (T_ACI_CMD_SRC)srcId, &pbText, | |
920 CPBF_MOD_NextSearch, &found, &pblst[0] ); | |
921 #else /* #ifdef NO_ASCIIZ */ | |
922 ret = sAT_PlusCPBF( srcId, cvtdFindstr, | |
923 CPBF_MOD_NextSearch, &found, &pblst[0] ); | |
924 #endif /* #ifdef NO_ASCIIZ */ | |
925 if (ret EQ AT_CMPL) | |
926 { | |
927 for(j=0;j < MAX_PB_ENTR AND i < found;j++) | |
928 { | |
929 type = toa_merge(pblst[j].type); | |
930 | |
931 pos=sprintf(g_sa,"+CPBF: %d,\"%s\",%d,", | |
932 pblst[j].index, | |
933 pblst[j].number, | |
934 type); | |
935 utl_chsetFromGsm((UBYTE*)pblst[j].text.data, | |
936 pblst[j].text.len, | |
937 (UBYTE*)cvtdText, | |
938 sizeof(cvtdText), | |
939 &lenCvtdText, | |
940 GSM_ALPHA_Def); | |
941 pos+=sprints(g_sa+pos,cvtdText,lenCvtdText); | |
942 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
943 i++; | |
944 } | |
945 } | |
946 else | |
947 { | |
948 i = found; /* Ensure at least termination of loop */ | |
949 } | |
950 } | |
951 } | |
952 } | |
953 else | |
954 { | |
955 cmdCmeError(CME_ERR_Unknown); | |
956 } | |
957 return (map_aci_2_ati_rslt(ret)); | |
958 | |
959 #endif /* no FF_ATI_BAT */ | |
960 } | |
961 | |
962 GLOBAL T_ATI_RSLT tesatPlusCPBF(char *cl, UBYTE srcId) | |
963 { | |
964 #ifndef FF_ATI_BAT | |
965 T_ACI_RETURN ret = AT_FAIL; | |
966 UBYTE nlength, | |
967 tlength; | |
968 #endif | |
969 | |
970 TRACE_FUNCTION("tesatPlusCPBF()"); | |
971 | |
972 #ifdef FF_ATI_BAT | |
973 { | |
974 T_BAT_cmd_send cmd; | |
975 T_BAT_no_parameter dummy; | |
976 | |
977 cmd.ctrl_params = BAT_CMD_TST_PLUS_CPBF; | |
978 dummy.bat_dummy = 0xFF; | |
979 cmd.params.ptr_tst_plus_cpbf = &dummy; | |
980 bat_send(ati_bat_get_client(srcId), &cmd); | |
981 return(ATI_EXCT); | |
982 } | |
983 #else /* no FF_ATI_BAT */ | |
984 | |
985 ret = tAT_PlusCPBF((T_ACI_CMD_SRC)srcId,&nlength,&tlength); | |
986 if(ret EQ AT_CMPL) | |
987 { | |
988 resp_disp(srcId, cl,"bb",&nlength,&tlength); | |
989 } | |
990 else | |
991 { | |
992 cmdCmeError(CME_ERR_Unknown); | |
993 } | |
994 return (map_aci_2_ati_rslt(ret)); | |
995 | |
996 #endif /* no FF_ATI_BAT */ | |
997 } | |
998 | |
999 /* | |
1000 +--------------------------------------------------------------------+ | |
1001 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1002 | STATE : code ROUTINE : atPlusCSVM | | |
1003 +--------------------------------------------------------------------+ | |
1004 | |
1005 PURPOSE : +CSVM command (Set Voice Mail Number ) | |
1006 */ | |
1007 | |
1008 GLOBAL T_ATI_RSLT setatPlusCSVM (char *cl, UBYTE srcId) | |
1009 { | |
1010 | |
1011 T_ACI_CSVM_MOD mode = CSVM_MOD_NotPresent; | |
1012 T_ACI_RETURN ret = AT_FAIL; | |
1013 T_ACI_TOA type; | |
1014 SHORT toa_val=0; | |
1015 CHAR numBuf[MAX_CC_ORIG_NUM_LEN]; | |
1016 | |
1017 TRACE_FUNCTION("setatPlusCSVM()"); | |
1018 | |
1019 memset( numBuf, 0, sizeof(numBuf)); | |
1020 | |
1021 cl=parse(cl,"dsr",&mode,(LONG)MAX_CC_ORIG_NUM_LEN, | |
1022 numBuf,&toa_val); | |
1023 | |
1024 if(!cl) | |
1025 { | |
1026 cmdCmeError(CME_ERR_OpNotAllow); | |
1027 return ATI_FAIL; | |
1028 } | |
1029 if ( mode EQ CSVM_MOD_Enable AND | |
1030 numBuf[0] EQ '\0' OR | |
1031 toa_val < 0) | |
1032 { | |
1033 cmdCmeError(CME_ERR_OpNotAllow); | |
1034 return ATI_FAIL; | |
1035 } | |
1036 if(toa_val NEQ 0) | |
1037 { | |
1038 type=toa_demerge(toa_val); | |
1039 } | |
1040 else | |
1041 { | |
1042 cmh_setToaDef(numBuf,&type); | |
1043 } | |
1044 | |
1045 | |
1046 #ifdef FF_ATI_BAT | |
1047 | |
1048 { | |
1049 T_BAT_cmd_send cmd; | |
1050 T_BAT_cmd_set_plus_csvm csvm; | |
1051 UBYTE len; | |
1052 | |
1053 cmd.ctrl_params = BAT_CMD_SET_PLUS_CSVM; | |
1054 cmd.params.ptr_set_plus_csvm=&csvm; | |
1055 | |
1056 len=strlen(numBuf); | |
1057 | |
1058 csvm.mode=(T_BAT_plus_csvm_mode)mode; | |
1059 | |
1060 if ((len) AND (len<=BAT_MAX_CSVM_NUMBER_LEN)) | |
1061 { | |
1062 csvm.v_number=TRUE; | |
1063 csvm.c_number=(U8)len; | |
1064 memcpy(csvm.number,numBuf,len); | |
1065 } | |
1066 else | |
1067 { | |
1068 csvm.v_number=FALSE; | |
1069 } | |
1070 csvm.type=(S16)toa_val; | |
1071 bat_send(ati_bat_get_client(srcId), &cmd); | |
1072 return(ATI_EXCT); | |
1073 } | |
1074 | |
1075 #else /* no FF_ATI_BAT */ | |
1076 | |
1077 ret = sAT_PlusCSVM((T_ACI_CMD_SRC)srcId, mode, numBuf, (UBYTE)strlen(numBuf), &type); | |
1078 | |
1079 if (ret EQ AT_FAIL) | |
1080 { | |
1081 cmdCmeError(CME_ERR_Unknown); | |
1082 } | |
1083 return (map_aci_2_ati_rslt(ret)); | |
1084 | |
1085 #endif /* no FF_ATI_BAT */ | |
1086 } | |
1087 | |
1088 GLOBAL T_ATI_RSLT queatPlusCSVM (char *cl, UBYTE srcId) | |
1089 { | |
1090 T_ACI_CSVM_MOD mode=CSVM_MOD_NotPresent; | |
1091 T_ACI_RETURN ret = AT_FAIL; | |
1092 SHORT toa_val=0; | |
1093 CHAR numBuf[MAX_CC_ORIG_NUM_LEN]; | |
1094 | |
1095 TRACE_FUNCTION("queatPlusCSVM()"); | |
1096 | |
1097 memset( numBuf, 0, sizeof(numBuf)); | |
1098 | |
1099 #ifdef FF_ATI_BAT | |
1100 { | |
1101 T_BAT_cmd_send cmd; | |
1102 T_BAT_no_parameter dummy; | |
1103 | |
1104 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CSVM; | |
1105 dummy.bat_dummy = 0xFF; | |
1106 cmd.params.ptr_que_plus_csvm = &dummy; | |
1107 bat_send(ati_bat_get_client(srcId), &cmd); | |
1108 return(ATI_EXCT); | |
1109 } | |
1110 #else /* no FF_ATI_BAT */ | |
1111 | |
1112 ret = qAT_PlusCSVM((T_ACI_CMD_SRC)srcId, &mode, numBuf, sizeof(numBuf), &toa_val); | |
1113 if (ret EQ AT_FAIL) | |
1114 { | |
1115 cmdCmeError(CME_ERR_Unknown); | |
1116 } | |
1117 else | |
1118 { | |
1119 sprintf(g_sa,"+CSVM: %d,\"%s\",%d",mode,numBuf,toa_val); | |
1120 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1121 } | |
1122 | |
1123 return (map_aci_2_ati_rslt(ret)); | |
1124 | |
1125 #endif /* no FF_ATI_BAT */ | |
1126 } | |
1127 | |
1128 /* | |
1129 +--------------------------------------------------------------------+ | |
1130 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1131 | STATE : code ROUTINE : atPlusCLAN | | |
1132 +--------------------------------------------------------------------+ | |
1133 | |
1134 PURPOSE : +CLAN command (Set language) | |
1135 */ | |
1136 | |
1137 GLOBAL T_ATI_RSLT setatPlusCLAN (CHAR *cl, UBYTE srcId) | |
1138 { | |
1139 T_ACI_RETURN ret = AT_FAIL; | |
1140 CHAR lng_str[CLAN_CODE_LEN+1]={0}; | |
1141 SHORT i; | |
1142 T_ACI_LAN_SUP lngCde; | |
1143 CHAR *auptr="au"; | |
1144 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1145 | |
1146 TRACE_FUNCTION("setatPlusCLAN()"); | |
1147 | |
1148 cl = parse(cl,"s",(LONG)3,lng_str); | |
1149 if(!cl OR *lng_str EQ '\0') | |
1150 { | |
1151 cmdCmeError(CME_ERR_OpNotAllow); | |
1152 return ATI_FAIL; | |
1153 } | |
1154 if (strcmp(lng_str, auptr)) | |
1155 { | |
1156 for(i=0;lngs[i].str NEQ 0;i++) | |
1157 { | |
1158 if (!strcmp(lngs[i].str,lng_str)) | |
1159 { | |
1160 lngCde.str=lngs[i].str; | |
1161 lngCde.lng=lngs[i].lng; | |
1162 break; | |
1163 } | |
1164 } | |
1165 if(lngs[i].str EQ 0) | |
1166 { | |
1167 cmdCmeError(CME_ERR_OpNotSupp); | |
1168 return ATI_FAIL; | |
1169 } | |
1170 } | |
1171 else | |
1172 { | |
1173 lngCde.str = lng_str; | |
1174 lngCde.lng = CLAN_LNG_AUT; | |
1175 } | |
1176 | |
1177 #ifdef FF_ATI_BAT | |
1178 | |
1179 { | |
1180 T_BAT_cmd_send cmd; | |
1181 T_BAT_cmd_set_plus_clan clan; | |
1182 UBYTE len; | |
1183 | |
1184 cmd.ctrl_params = BAT_CMD_SET_PLUS_CLAN; | |
1185 cmd.params.ptr_set_plus_clan=&clan; | |
1186 | |
1187 len=strlen(lng_str); | |
1188 | |
1189 if (len>BAT_MAX_CLAN_CODE_LEN) | |
1190 { | |
1191 cmdCmeError(CME_ERR_Unknown); | |
1192 return ATI_FAIL; | |
1193 } | |
1194 | |
1195 memcpy(clan.code,lng_str,len); | |
1196 clan.c_code=(U8)len; | |
1197 bat_send(ati_bat_get_client(srcId), &cmd); | |
1198 src_params->curAtCmd=AT_CMD_CLAN; | |
1199 return(ATI_EXCT); | |
1200 } | |
1201 | |
1202 #else /* no FF_ATI_BAT */ | |
1203 | |
1204 ret = sAT_PlusCLAN((T_ACI_CMD_SRC)srcId,&lngCde); | |
1205 if (ret EQ AT_EXCT) | |
1206 { | |
1207 src_params->curAtCmd = AT_CMD_CLAN; | |
1208 } | |
1209 else if (ret EQ AT_FAIL) | |
1210 { | |
1211 cmdCmeError(CME_ERR_Unknown); | |
1212 } | |
1213 return (map_aci_2_ati_rslt(ret)); | |
1214 | |
1215 #endif /* no FF_ATI_BAT */ | |
1216 } | |
1217 | |
1218 GLOBAL T_ATI_RSLT queatPlusCLAN(char *cl, UBYTE srcId) | |
1219 { | |
1220 #ifndef FF_ATI_BAT | |
1221 CHAR *me="+CLAN: "; | |
1222 T_ACI_RETURN ret = AT_FAIL; | |
1223 T_ACI_LAN_SUP lngCde; | |
1224 CHAR lang_buffer[3]; /* 2 chars for language + 0 terminated string */ | |
1225 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1226 #endif | |
1227 | |
1228 TRACE_FUNCTION("queatPlusCLAN()"); | |
1229 | |
1230 #ifdef FF_ATI_BAT | |
1231 { | |
1232 T_BAT_cmd_send cmd; | |
1233 T_BAT_no_parameter dummy; | |
1234 | |
1235 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CLAN; | |
1236 dummy.bat_dummy = 0xFF; | |
1237 cmd.params.ptr_que_plus_clan = &dummy; | |
1238 bat_send(ati_bat_get_client(srcId), &cmd); | |
1239 return(ATI_EXCT); | |
1240 } | |
1241 #else /* no FF_ATI_BAT */ | |
1242 | |
1243 /* to be sure that last cipher is 0 (string)*/ | |
1244 memset(lang_buffer, 0, sizeof(lang_buffer)); | |
1245 lngCde.str = lang_buffer; | |
1246 | |
1247 ret = qAT_PlusCLAN((T_ACI_CMD_SRC)srcId, &lngCde); | |
1248 switch(ret) | |
1249 { | |
1250 case(AT_CMPL): | |
1251 sprintf(g_sa,"%s%s", me, lngCde.str); | |
1252 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1253 break; | |
1254 | |
1255 case(AT_EXCT): | |
1256 src_params->curAtCmd = AT_CMD_CLAN; | |
1257 break; | |
1258 | |
1259 case(AT_BUSY): | |
1260 cmdCmeError(CME_ERR_SimBusy); | |
1261 break; | |
1262 | |
1263 default: | |
1264 cmdCmeError(CME_ERR_Unknown); | |
1265 break; | |
1266 } | |
1267 return (map_aci_2_ati_rslt(ret)); | |
1268 | |
1269 #endif /* no FF_ATI_BAT */ | |
1270 } | |
1271 | |
1272 GLOBAL T_ATI_RSLT tesatPlusCLAN (CHAR *cl, UBYTE srcId) | |
1273 { | |
1274 #ifndef FF_ATI_BAT | |
1275 char *me="+CLAN: "; | |
1276 T_ACI_RETURN ret = AT_FAIL; | |
1277 T_ACI_LAN_SUP lnglst[MAX_LAN]; | |
1278 SHORT lastIdx; | |
1279 UBYTE i; | |
1280 SHORT pos; | |
1281 #endif | |
1282 | |
1283 TRACE_FUNCTION("tesatPlusCLAN()"); | |
1284 | |
1285 #ifdef FF_ATI_BAT | |
1286 { | |
1287 T_BAT_cmd_send cmd; | |
1288 T_BAT_no_parameter dummy; | |
1289 | |
1290 cmd.ctrl_params = BAT_CMD_TST_PLUS_CLAN; | |
1291 dummy.bat_dummy = 0xFF; | |
1292 cmd.params.ptr_tst_plus_clan = &dummy; | |
1293 bat_send(ati_bat_get_client(srcId), &cmd); | |
1294 return(ATI_EXCT); | |
1295 } | |
1296 #else /* no FF_ATI_BAT */ | |
1297 | |
1298 ret = tAT_PlusCLAN((T_ACI_CMD_SRC)srcId, &lastIdx, &lnglst[0] ); | |
1299 if (ret EQ AT_FAIL) | |
1300 { | |
1301 cmdCmeError(CME_ERR_Unknown); | |
1302 return ATI_FAIL; | |
1303 } | |
1304 | |
1305 pos=sprintf(g_sa,"%s",me); | |
1306 | |
1307 for(i=0;i<lastIdx;i++) | |
1308 { | |
1309 pos += sprintf(g_sa+pos,"%s,",lnglst[i].str); | |
1310 } | |
1311 | |
1312 g_sa[pos-1] = '\0'; | |
1313 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1314 return (map_aci_2_ati_rslt(ret)); | |
1315 | |
1316 #endif /* no FF_ATI_BAT */ | |
1317 } | |
1318 | |
1319 /* | |
1320 +--------------------------------------------------------------------+ | |
1321 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1322 | STATE : code ROUTINE : setatPercentPBCF | | |
1323 +--------------------------------------------------------------------+ | |
1324 | |
1325 PURPOSE : %PBCF command (Set phonebook configuration) | |
1326 */ | |
1327 | |
1328 GLOBAL T_ATI_RSLT setatPercentPBCF (CHAR *cl, UBYTE srcId) | |
1329 { | |
1330 T_ACI_PBCF_LDN ldn = PBCF_LDN_NotPresent; | |
1331 T_ACI_PBCF_LRN lrn = PBCF_LRN_NotPresent; | |
1332 T_ACI_PBCF_LMN lmn = PBCF_LMN_NotPresent; | |
1333 T_ACI_RETURN ret = AT_FAIL; | |
1334 | |
1335 cl = parse (cl, "ddd", &ldn, &lrn, &lmn); | |
1336 | |
1337 /*lint -e685 always evaluates to false*/ | |
1338 if (!cl OR | |
1339 ldn < PBCF_LDN_NotPresent OR ldn > PBCF_LDN_Disable OR | |
1340 lrn < PBCF_LRN_NotPresent OR lrn > PBCF_LRN_Disable OR | |
1341 lmn < PBCF_LMN_NotPresent OR lmn > PBCF_LMN_Disable) | |
1342 { | |
1343 cmdCmeError(CME_ERR_OpNotAllow); | |
1344 return ATI_FAIL; | |
1345 } | |
1346 | |
1347 #ifdef FF_ATI_BAT | |
1348 { | |
1349 T_BAT_cmd_send cmd; | |
1350 T_BAT_cmd_set_percent_pbcf pbcf; | |
1351 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1352 | |
1353 TRACE_FUNCTION("setatPercentPBCF() calls bat_send() <=== as APPLICATION"); | |
1354 | |
1355 cmd.ctrl_params = BAT_CMD_SET_PERCENT_PBCF; | |
1356 cmd.params.ptr_set_percent_pbcf=&pbcf; | |
1357 | |
1358 pbcf.ldn = (T_BAT_percent_pbcf_ldn)ldn; | |
1359 pbcf.lrn = (T_BAT_percent_pbcf_lrn)lrn; | |
1360 pbcf.lmn = (T_BAT_percent_pbcf_lmn)lmn; | |
1361 | |
1362 bat_send(ati_bat_get_client(srcId), &cmd); | |
1363 src_params->curAtCmd=AT_CMD_P_PBCF; | |
1364 return(ATI_EXCT); | |
1365 } | |
1366 | |
1367 #else /* FF_ATI_BAT */ | |
1368 TRACE_FUNCTION("setatPercentPBCF()"); | |
1369 | |
1370 ret = sAT_PercentPBCF((T_ACI_CMD_SRC)srcId, ldn, lrn, lmn); | |
1371 | |
1372 if(ret EQ AT_FAIL) | |
1373 { | |
1374 cmdCmeError(CME_ERR_Unknown); | |
1375 return ATI_FAIL; | |
1376 } | |
1377 | |
1378 return (map_aci_2_ati_rslt(ret)); | |
1379 | |
1380 #endif /* FF_ATI_BAT */ | |
1381 } | |
1382 | |
1383 | |
1384 GLOBAL T_ATI_RSLT queatPercentPBCF (CHAR *cl, UBYTE srcId) | |
1385 { | |
1386 #ifdef FF_ATI_BAT | |
1387 { | |
1388 T_BAT_cmd_send cmd; | |
1389 T_BAT_no_parameter dummy; | |
1390 | |
1391 TRACE_FUNCTION("queatPercentPBCF() calls bat_send() <=== as APPLICATION"); | |
1392 | |
1393 cmd.ctrl_params = BAT_CMD_QUE_PERCENT_PBCF; | |
1394 dummy.bat_dummy = 0xFF; | |
1395 cmd.params.ptr_que_percent_pbcf = &dummy; | |
1396 bat_send(ati_bat_get_client(srcId), &cmd); | |
1397 return(ATI_EXCT); | |
1398 } | |
1399 | |
1400 #else /* FF_ATI_BAT */ | |
1401 CHAR *me = "%PBCF: "; | |
1402 T_ACI_PBCF_LDN ldn = PBCF_LDN_NotPresent; | |
1403 T_ACI_PBCF_LRN lrn = PBCF_LRN_NotPresent; | |
1404 T_ACI_PBCF_LMN lmn = PBCF_LMN_NotPresent; | |
1405 | |
1406 TRACE_FUNCTION("queatPercentPBCF()"); | |
1407 | |
1408 qAT_PercentPBCF ((T_ACI_CMD_SRC)srcId, &ldn, &lrn, &lmn); | |
1409 | |
1410 sprintf (g_sa, "%s%d, %d, %d", me, ldn, lrn, lmn); | |
1411 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1412 | |
1413 return (ATI_CMPL); | |
1414 #endif /* FF_ATI_BAT */ | |
1415 } | |
1416 | |
1417 #endif /* ATI_PHB_C */ |