FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/ati_phb.c @ 0:75a11d740a02

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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 */