FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/cmh_ccf.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-PS (6147)
4 | Modul : CMH_CCF
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 : This module defines the functions used by the command
18 | handler for call control.
19 +-----------------------------------------------------------------------------
20 */
21
22 #ifndef CMH_CCF_C
23 #define CMH_CCF_C
24 #endif
25
26 #include "config.h"
27 #include "fixedconf.h"
28 #include "condat-features.h"
29 #include "aci_conf.h"
30
31 #include "aci_all.h"
32
33 /*==== INCLUDES ===================================================*/
34
35 #include "aci_cmh.h"
36 #include "ati_cmd.h"
37 #include "aci_cmd.h"
38 #include "aci_mem.h"
39
40 #ifdef FAX_AND_DATA
41 #include "aci_fd.h"
42 #endif
43
44 #ifdef FF_TTY
45 #include "audio.h"
46 #endif
47
48 #include "aci_io.h"
49
50 #include "phb.h"
51 #include "ksd.h"
52 #include "aoc.h"
53 #include "aci.h"
54 #include "psa.h"
55 #include "psa_cc.h"
56 #include "psa_ss.h"
57 #include "psa_util.h"
58 #include "cmh.h"
59 #include "cmh_cc.h"
60 #include "cmh_ss.h"
61 #include "cmh_phb.h"
62
63 #include "aci_lst.h"
64
65 #ifdef DTI
66 #include "dti.h" /* functionality of the dti library */
67 #include "dti_conn_mng.h"
68 #include "dti_cntrl_mng.h"
69 #endif
70
71 #ifdef UART
72 #include "psa_uart.h"
73 #include "cmh_uart.h"
74 #endif
75
76 #ifdef FAX_AND_DATA
77
78 #include "psa_ra.h"
79 #include "cmh_ra.h"
80 #include "psa_l2r.h"
81 #include "cmh_l2r.h"
82
83 #ifdef FF_FAX
84 #include "psa_t30.h"
85 #include "cmh_t30.h"
86 #endif /* FF_FAX */
87
88 #endif /* FAX_AND_DATA */
89
90 #if defined (FF_WAP) || defined (FF_PPP) || defined(FF_GPF_TCPIP) || defined (FF_SAT_E)
91 #include "wap_aci.h"
92 #include "psa_ppp_w.h"
93 #include "cmh_ppp.h"
94 #endif /* of FF_WAP or FF_PPP || (FF_GPF_TCPIP)|| (FF_SAT_E)*/
95
96 #ifdef FF_GPF_TCPIP
97 #include "dcm_utils.h"
98 #include "dcm_state.h"
99 #include "dcm_env.h"
100 #endif
101
102 #ifdef SIM_TOOLKIT
103 #include "psa_sat.h"
104 #include "cmh_sat.h"
105 #include "psa_sim.h"
106 #endif
107
108 #ifdef FF_PSI
109 #include "psa_psi.h"
110 #include "cmh_psi.h"
111 #endif /*FF_PSI*/
112 #include "l4_tim.h"
113
114 #if defined(_TARGET_)
115 #include "../../services/ffs/ffs.h"
116 #include "ffs_coat.h"
117 #endif /* _TARGET_ */
118
119 #include "dcm_f.h"
120
121 /*==== CONSTANTS ==================================================*/
122 #define ACI_MAX_DIAL_SHORT_STRING_LEN 2
123 #ifdef TI_PS_FF_AT_P_CMD_RDLB
124 EXTERN T_ACI_CC_REDIAL_BLACKL * cc_blacklist_ptr;
125 #endif /* TI_PS_FF_AT_P_CMD_RDLB */
126 /*==== TYPES ======================================================*/
127
128 /*==== EXPORT =====================================================*/
129
130 /*==== VARIABLES ==================================================*/
131 GLOBAL T_ACI_CUSCFG_PARAMS cuscfgParams;
132
133 /* Implements Measure#32: Row 73, 74, 103, 114 & 1071 */
134 const char * const gsm_com_path="/gsm/com";
135 const char * const gsm_com_redialmode_path="/gsm/com/redialMode";
136 const char * const gsm_com_alslock_path="/gsm/com/ALSlock";
137 const char * const gsm_com_rfcap_path="/gsm/com/rfcap";
138 /*==== FUNCTIONS ==================================================*/
139 /* Implements Measure 197, 198 and 199 */
140 LOCAL void cmhCC_redialAttempt( SHORT cId, UBYTE rdlCnt );
141
142 /*
143 +-------------------------------------------------------------------+
144 | PROJECT : GSM-PS (6147) MODULE : CMH |
145 | ROUTINE : cmhCC_PrepareCmdEnd |
146 +-------------------------------------------------------------------+
147
148 PURPOSE : Prepares the end of a CC related AT command.
149 cId describes a valid (non-NULL) call table entry.
150
151 */
152
153 GLOBAL void cmhCC_PrepareCmdEnd (SHORT cId, UBYTE *cmdBuf, UBYTE *srcBuf)
154 {
155 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
156
157 if (cmdBuf NEQ NULL)
158 *cmdBuf = ctb->curCmd;
159 if (srcBuf NEQ NULL)
160 *srcBuf = ctb->curSrc;
161 ctb->curCmd = AT_CMD_NONE;
162 ctb->curSrc = CMD_SRC_NONE;
163 }
164
165
166 GLOBAL UBYTE cmhCC_set_speech_serv (T_CC_CMD_PRM *pCCCmdPrm)
167 {
168 #ifdef FF_TTY
169 UBYTE ctmReq;
170
171 /* check temporary inversion of CTM service request */
172 if (!ccShrdPrm.ctmOvwr)
173 {
174 ctmReq = ccShrdPrm.ctmReq;
175 }
176 else
177 {
178 if (ccShrdPrm.ctmReq EQ MNCC_CTM_ENABLED)
179 {
180 ctmReq = MNCC_CTM_DISABLED;
181 ccShrdPrm.ttyCmd = (UBYTE)TTY_OFF;
182 }
183 else
184 {
185 ctmReq = MNCC_CTM_ENABLED;
186 ccShrdPrm.ttyCmd = (UBYTE)TTY_ALL;
187 }
188 /* reset temporary inversion */
189 ccShrdPrm.ctmOvwr = FALSE;
190 }
191 #endif /* FF_TTY */
192 #ifdef FF_TTY
193 if (ctmReq EQ MNCC_CTM_ENABLED)
194 {
195 if (ccShrdPrm.ctmState EQ TTY_STATE_NONE)
196 {
197 ccShrdPrm.ctmState = TTY_STATE_IDLE;
198 }
199 if (pCCCmdPrm->ALSmode EQ ALS_MOD_AUX_SPEECH)
200 {
201 return MNCC_BEARER_SERV_AUX_SPEECH_CTM;
202 }
203 else
204 {
205 return MNCC_BEARER_SERV_SPEECH_CTM;
206 }
207 }
208 else
209 #endif /* FF_TTY */
210 {
211 #ifdef FF_TTY
212 if (ccShrdPrm.ctmState EQ TTY_STATE_IDLE)
213 {
214 ccShrdPrm.ctmState = TTY_STATE_NONE;
215 }
216 #endif /* FF_TTY */
217 if (pCCCmdPrm->ALSmode EQ ALS_MOD_AUX_SPEECH)
218 {
219 return MNCC_BEARER_SERV_AUX_SPEECH;
220 }
221 }
222 return MNCC_BEARER_SERV_SPEECH;
223 }
224
225 GLOBAL T_ACI_RETURN cmhCC_chkShortString (T_ACI_CMD_SRC srcId,
226 SHORT cId,
227 T_CLPTY_PRM *cldPty)
228 {
229 USHORT num_len;
230 T_ACI_KSD_USSD_PRM ksdString;
231
232 num_len = strlen (cldPty->num);
233
234 /* check the length */
235 if (!num_len OR (num_len > ACI_MAX_DIAL_SHORT_STRING_LEN))
236 {
237 return (AT_EXCT);
238 }
239
240 ksdString.ussd = (UBYTE*)cldPty->num;
241
242 /* check if MS is in a call */
243 if (cId NEQ NO_ENTRY)
244 {
245 /* call is active */
246 return (cmhSS_ksdUSSD (srcId, &ksdString));
247 }
248
249 /* check if input string is 2 digit starting with a 1 */
250 if ((num_len EQ ACI_MAX_DIAL_SHORT_STRING_LEN) AND
251 (*(cldPty->num) EQ '1') OR cuscfgParams.Two_digit_MO_Call)
252 {
253 /* normal dial */
254 return (AT_EXCT);
255 }
256
257 return (cmhSS_ksdUSSD (srcId, &ksdString));
258 }
259
260 /*
261 +-------------------------------------------------------------------+
262 | PROJECT : GSM-PS (6147) MODULE : CMH |
263 | ROUTINE : cmhCC_find_call_for_DTMF|
264 +-------------------------------------------------------------------+
265
266 PURPOSE :searches for a call where it is possible to
267 send DTMF tones.
268 */
269 GLOBAL BOOL is_call_ok_for_dtmf( SHORT cId )
270 {
271 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
272
273 if(calltype NEQ VOICE_CALL)
274 {
275 TRACE_EVENT_P1("calltype NEQ VOICE_CALL: %d", calltype);
276 return(FALSE);
277 }
278
279 if (ccShrdPrm.ctb[cId] EQ NULL)
280 {
281 TRACE_EVENT("ccShrdPrm.ctb[cId] EQ NULL");
282 return(FALSE);
283 }
284
285 switch(psaCC_ctb(cId)->calStat)
286 {
287 case(CS_ACT):
288 case(CS_ACT_REQ):
289 case(CS_DSC_REQ):
290 case(CS_CPL_REQ):
291 return(TRUE);
292
293 default:
294 TRACE_EVENT_P1("unexpected call status: %d", psaCC_ctb(cId)->calStat);
295 return(FALSE);
296 }
297 }
298
299 GLOBAL SHORT cmhCC_find_call_for_DTMF( void )
300 {
301 SHORT ctbIdx; /* holds call table index */
302
303 TRACE_FUNCTION("cmhCC_find_call_for_DTMF");
304
305 for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
306 {
307 if( is_call_ok_for_dtmf(ctbIdx) )
308 {
309 return(ctbIdx);
310 }
311 }
312 return( NO_ENTRY );
313 }
314
315 /*
316 +-------------------------------------------------------------------+
317 | PROJECT : GSM-PS (6147) MODULE : CMH |
318 | ROUTINE : cmhCC_SendDTMFdig |
319 +-------------------------------------------------------------------+
320
321 PURPOSE : send a DTMF digit for that call.
322 return value: TRUE if digit has been correctly proceeded.
323 FALSE if an error occured.
324 */
325
326 GLOBAL BOOL cmhCC_SendDTMFdig( T_ACI_AT_CMD cmd, SHORT cId, CHAR digit, UBYTE mode)
327 {
328 TRACE_FUNCTION("cmhCC_SendDTMFdig");
329
330 TRACE_EVENT_P1("Sending DTMF tone: %d", digit);
331
332 switch( digit )
333 {
334 case( '0' ):
335 case( '1' ):
336 case( '2' ):
337 case( '3' ):
338 case( '4' ):
339 case( '5' ):
340 case( '6' ):
341 case( '7' ):
342 case( '8' ):
343 case( '9' ):
344 case( '*' ):
345 case( '#' ):
346 case( 'A' ):
347 case( 'B' ):
348 case( 'C' ):
349 case( 'D' ):
350 psaCC_SendDTMF( cId, digit, mode );
351 return( TRUE );
352
353 case( 'W' ): /* FIXME: w should prompt the user for starting sending the following DTMF tones */
354 case( 'w' ): /* since BMI does not support 'w' we assume to be the same as 'p' */
355 case( 'P' ):
356 case( 'p' ):
357 if(cmd NEQ AT_CMD_VTS) /* this is only valid within a number to dial */
358 {
359 /* p within a number string: this is a 3 seconds pause */
360 TRACE_EVENT("DTMF pause requested: 3 seconds");
361 #if defined (NEW_FRAME)
362 TIMERSTART( TDTMF_VALUE, ACI_TDTMF );
363 #else
364 TIMERSTART( TDTMF_VALUE, t_dtmf_handle );
365 #endif
366 return( TRUE );
367 }
368 /* fallthrough for else */
369 /*lint -fallthrough*/
370 default:
371 TRACE_EVENT_P1("Invalid DTMF digit: %d", digit);
372 }
373 return( FALSE );
374 }
375
376
377 #ifdef FAX_AND_DATA
378 /*
379 +-------------------------------------------------------------------+
380 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
381 | ROUTINE : cmhCC_SelRate |
382 +-------------------------------------------------------------------+
383
384 PURPOSE : select the user rate out of the current speed setting
385
386 */
387
388 GLOBAL UBYTE cmhCC_SelRate ( T_ACI_BS_SPEED speed )
389 {
390 switch( speed )
391 {
392 case( BS_SPEED_300_V21 ):
393 case( BS_SPEED_300_V110 ): return( MNCC_UR_0_3_KBIT );
394 case( BS_SPEED_1200_V22 ):
395 case( BS_SPEED_1200_V120 ):
396 case( BS_SPEED_1200_V110 ): return( MNCC_UR_1_2_KBIT );
397 case( BS_SPEED_1200_75_V23 ): return( MNCC_UR_1_2_KBIT_V23 );
398 case( BS_SPEED_2400_V22bis ):
399 case( BS_SPEED_2400_V26ter ):
400 case( BS_SPEED_2400_V120 ):
401 case( BS_SPEED_2400_V110 ): return( MNCC_UR_2_4_KBIT );
402 case( BS_SPEED_4800_V32 ):
403 case( BS_SPEED_4800_V120 ):
404 case( BS_SPEED_4800_V110 ): return( MNCC_UR_4_8_KBIT );
405 case( BS_SPEED_AUTO ):
406 case( BS_SPEED_9600_V32 ):
407 case( BS_SPEED_9600_V34 ):
408 case( BS_SPEED_9600_V120 ):
409 case( BS_SPEED_9600_V110 ): return( MNCC_UR_9_6_KBIT );
410 case( BS_SPEED_14400_V34 ):
411 case( BS_SPEED_14400_V120 ):
412 case( BS_SPEED_14400_V110 ): return( MNCC_UR_14_4_KBIT );
413 default: return( MNCC_UR_NOT_PRES );
414 }
415 }
416
417 /*
418 +-------------------------------------------------------------------+
419 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
420 | ROUTINE : cmhCC_SelMT |
421 +-------------------------------------------------------------------+
422
423 PURPOSE : select the modem type out of the current speed setting
424
425 */
426
427 GLOBAL UBYTE cmhCC_SelMT ( T_ACI_BS_SPEED speed )
428 {
429 switch( speed )
430 {
431 case( BS_SPEED_300_V21 ): return( MNCC_MT_V21 );
432 case( BS_SPEED_1200_V22 ): return( MNCC_MT_V22 );
433 case( BS_SPEED_2400_V22bis ): return( MNCC_MT_V22_BIS );
434 case( BS_SPEED_1200_75_V23 ): return( MNCC_MT_V23 );
435 case( BS_SPEED_2400_V26ter ): return( MNCC_MT_V26_TER );
436 case( BS_SPEED_9600_V32 ):
437 case( BS_SPEED_4800_V32 ): return( MNCC_MT_V32 );
438 case( BS_SPEED_1200_V120 ):
439 case( BS_SPEED_2400_V120 ):
440 case( BS_SPEED_4800_V120 ):
441 case( BS_SPEED_9600_V120 ):
442 case( BS_SPEED_14400_V120 ):
443 case( BS_SPEED_2400_V110 ):
444 case( BS_SPEED_4800_V110 ):
445 case( BS_SPEED_9600_V110 ):
446 case( BS_SPEED_14400_V110 ):
447 case( BS_SPEED_300_V110 ):
448 case( BS_SPEED_1200_V110 ): return( MNCC_MT_NONE );
449 case( BS_SPEED_9600_V34 ):
450 case( BS_SPEED_14400_V34 ): return( MNCC_MT_V34 );
451 default: return( MNCC_MT_AUTOBAUD );
452 }
453 }
454
455
456 /*
457 +-------------------------------------------------------------------+
458 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
459 | ROUTINE : cmhCC_SelTransferCap |
460 +-------------------------------------------------------------------+
461
462 PURPOSE : select the transfer capabilty on basis of speed
463
464 */
465
466 GLOBAL UBYTE cmhCC_SelTransferCap ( T_ACI_BS_SPEED speed )
467 {
468 TRACE_FUNCTION("cmhCC_SelTransferCap()");
469
470 if (speed <= BS_SPEED_14400_V34)
471 {
472 return MNCC_ITC_NONE;
473 }
474 else
475 {
476 return MNCC_ITC_UDI;
477 }
478 }
479
480 /*
481 +-------------------------------------------------------------------+
482 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
483 | ROUTINE : cmhCC_SelRateAdaption |
484 +-------------------------------------------------------------------+
485
486 PURPOSE : select the rate adaption on basis of speed selection
487
488 */
489
490 GLOBAL UBYTE cmhCC_SelRateAdaption ( T_ACI_BS_SPEED speed)
491 {
492 TRACE_FUNCTION("cmhCC_SelRateAdaption()");
493
494 if ((speed >= BS_SPEED_1200_V120) AND (speed <= BS_SPEED_14400_V120))
495 {
496 return MNCC_RATE_ADAPT_V120;
497 }
498 else if ((speed >= BS_SPEED_300_V110) AND (speed <= BS_SPEED_14400_V110))
499 {
500 return MNCC_RATE_ADAPT_V110;
501 }
502 else
503 {
504 return MNCC_RATE_ADAPT_NONE;
505 }
506 }
507 /*
508 +-------------------------------------------------------------------+
509 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
510 | ROUTINE : cmhCC_SelServ |
511 +-------------------------------------------------------------------+
512
513 PURPOSE : select the bearer service out of the current name setting
514
515 */
516
517 GLOBAL UBYTE cmhCC_SelServ ( T_ACI_CBST_NAM name )
518 {
519 switch( name )
520 {
521 case( CBST_NAM_Asynch ): return( MNCC_BEARER_SERV_ASYNC );
522 case( CBST_NAM_Synch ): return( MNCC_BEARER_SERV_SYNC );
523 default: return( MNCC_BEARER_SERV_NOT_PRES );
524 }
525
526 }
527
528 /*
529 +-------------------------------------------------------------------+
530 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
531 | ROUTINE : cmhCC_SelCE |
532 +-------------------------------------------------------------------+
533
534 PURPOSE : select the connection element out of the current ce setting
535
536 */
537
538 GLOBAL UBYTE cmhCC_SelCE ( T_ACI_CBST_CE ce )
539 {
540 switch( ce )
541 {
542 case( CBST_CE_Transparent ): return( MNCC_CONN_ELEM_TRANS );
543 case( CBST_CE_NonTransparent ): return( MNCC_CONN_ELEM_NON_TRANS );
544 case( CBST_CE_BothTransPref ): return( MNCC_CONN_ELEM_TRANS_PREF );
545 case( CBST_CE_BothNonTransPref ): return( MNCC_CONN_ELEM_NON_TRANS_PREF );
546 default: return( MNCC_CONN_ELEM_NOT_PRES );
547 }
548 }
549
550 /*
551 +-------------------------------------------------------------------+
552 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
553 | ROUTINE : cmhCC_SelStopBit |
554 +-------------------------------------------------------------------+
555
556 PURPOSE : select the stop bits out of the current character framing
557 setting
558
559 */
560
561 GLOBAL UBYTE cmhCC_SelStopBit ( T_ACI_CMD_SRC srcId )
562 {
563 #ifdef UART
564 if (UART_IO_SB_2 EQ cmhUART_GetStopBitOverSrcID( (UBYTE) srcId ))
565 {
566 return( MNCC_STOP_2_BIT );
567 }
568 #endif /*UART*/
569 #if defined (FF_PSI) AND defined (DTI)
570 if (UART_IO_SB_2 EQ cmhPSI_GetStopBitOverSrcID( (UBYTE) srcId ))
571 {
572 return( MNCC_STOP_2_BIT );
573 }
574 #endif /*FF_PSI*/
575
576 return( MNCC_STOP_1_BIT );
577 }
578
579
580 /*
581 +-------------------------------------------------------------------+
582 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
583 | ROUTINE : cmhCC_SelDataBit |
584 +-------------------------------------------------------------------+
585
586 PURPOSE : select the data bits out of the current character framing
587 setting
588
589 */
590
591 GLOBAL UBYTE cmhCC_SelDataBit ( T_ACI_CMD_SRC srcId )
592 {
593 #ifdef UART
594 if ( UART_IO_BPC_7 EQ cmhUART_GetDataBitOverSrcID( (UBYTE) srcId ))
595
596 {
597 return( MNCC_DATA_7_BIT );
598 }
599 #endif /*UART*/
600
601 #if defined (FF_PSI) AND defined (DTI)
602 if ( UART_IO_BPC_7 EQ cmhPSI_GetDataBitOverSrcID( (UBYTE) srcId ) )
603 {
604 return( MNCC_DATA_7_BIT );
605 }
606 #endif /*FF_PSI*/
607
608 return( MNCC_DATA_8_BIT );
609 }
610
611
612 /*
613 +-------------------------------------------------------------------+
614 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
615 | ROUTINE : cmhCC_SelParity |
616 +-------------------------------------------------------------------+
617
618 PURPOSE : select the data bits out of the current character framing
619 setting
620
621 */
622
623 GLOBAL UBYTE cmhCC_SelParity ( T_ACI_CMD_SRC srcId )
624 {
625 UBYTE parity=0;
626 #if defined (FF_PSI) AND defined (DTI)
627 T_ACI_DTI_PRC_PSI *src_infos = find_element (psi_src_params,
628 (UBYTE)srcId, cmhPSItest_srcId);
629
630 if (src_infos EQ NULL)
631 #endif /*FF_PSI*/
632
633 #ifdef UART
634 parity = cmhUART_GetParityOverSrcID( (UBYTE) srcId );
635 #else /*UART*/
636 parity=0;
637 #endif /*UART*/
638
639 #if defined (FF_PSI) AND defined (DTI)
640 else
641 parity = cmhPSI_GetParityOverSrcID( (UBYTE) srcId );
642 #endif /*FF_PSI*/
643 #ifdef UART
644 switch( parity )
645 {
646 case UART_IO_PA_NONE: return( MNCC_PARITY_NONE );
647 case UART_IO_PA_EVEN: return( MNCC_PARITY_EVEN );
648 case UART_IO_PA_ODD: return( MNCC_PARITY_ODD );
649 case UART_IO_PA_SPACE: return( MNCC_PARITY_FORCED_TO_0 );
650 case NOT_SUPPORTED_UART_IO_PA_MARK: return( MNCC_PARITY_FORCED_TO_1 );
651 default: TRACE_EVENT( "UNEXP PARITY IN ICF" );
652 }
653 #endif /*UART*/
654 return( MNCC_PARITY_NONE );
655
656 }
657 #endif /* FAX_AND_DATA */
658 /*
659 +-------------------------------------------------------------------+
660 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
661 | ROUTINE : cmhCC_GetCallType |
662 +-------------------------------------------------------------------+
663
664 PURPOSE : get call type out of bearer capabilities
665
666 */
667
668 GLOBAL SHORT cmhCC_GetCallType_from_bearer ( void * bearCap )
669 {
670 T_MNCC_bcpara * pBC = (T_MNCC_bcpara*) bearCap;
671
672 switch( pBC->bearer_serv )
673 {
674 case( MNCC_BEARER_SERV_SYNC ):
675 switch( pBC -> conn_elem )
676 {
677 case( MNCC_CONN_ELEM_TRANS ): return( CRING_SERV_TYP_Sync );
678 case( MNCC_CONN_ELEM_NON_TRANS ): return( CRING_SERV_TYP_RelSync );
679 default: TRACE_EVENT( "UNEXP CONN ELEMENT IN CTB" );
680 /*lint -fallthrough*/
681 case( MNCC_CONN_ELEM_NOT_PRES ): return( CRING_SERV_TYP_NotPresent );
682 }
683
684 case( MNCC_BEARER_SERV_ASYNC ):
685 switch( pBC -> conn_elem )
686 {
687 case( MNCC_CONN_ELEM_TRANS ): return( CRING_SERV_TYP_Async );
688 case( MNCC_CONN_ELEM_NON_TRANS ): return( CRING_SERV_TYP_RelAsync );
689 default: TRACE_EVENT( "UNEXP CONN ELEMENT IN CTB" );
690 /*lint -fallthrough*/
691 case( MNCC_CONN_ELEM_NOT_PRES ): return( CRING_SERV_TYP_NotPresent );
692 }
693
694 case( MNCC_BEARER_SERV_FAX ): return( CRING_SERV_TYP_Fax );
695
696 case( MNCC_BEARER_SERV_SPEECH_CTM ):
697 case( MNCC_BEARER_SERV_SPEECH ): return( CRING_SERV_TYP_Voice );
698
699 case( MNCC_BEARER_SERV_AUX_SPEECH_CTM):
700 case( MNCC_BEARER_SERV_AUX_SPEECH ): return( CRING_SERV_TYP_AuxVoice );
701
702 default: TRACE_EVENT( "UNEXP BEARER SERVICE IN CTB" );
703 /*lint -fallthrough*/
704 case( MNCC_BEARER_SERV_PAD_ACCESS ):
705 case( MNCC_BEARER_SERV_PACKET_ACCESS ):
706 case( MNCC_BEARER_SERV_NOT_PRES ): return( CRING_SERV_TYP_NotPresent );
707
708 }
709 }
710
711 #ifdef FAX_AND_DATA
712 /*
713 +-------------------------------------------------------------------+
714 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
715 | ROUTINE : cmhCC_GetSrvType |
716 +-------------------------------------------------------------------+
717
718 PURPOSE : get service type out of bearer capabilities
719
720 */
721
722 GLOBAL SHORT cmhCC_GetSrvType ( void * bearCap )
723 {
724 T_MNCC_bcpara * pBC = (T_MNCC_bcpara*) bearCap;
725
726 switch( pBC->bearer_serv )
727 {
728 case( MNCC_BEARER_SERV_SYNC ):
729 switch( pBC -> conn_elem )
730 {
731 case( MNCC_CONN_ELEM_TRANS ): return( CRING_SERV_TYP_Sync );
732 case( MNCC_CONN_ELEM_NON_TRANS ): return( CRING_SERV_TYP_RelSync );
733 default: TRACE_EVENT( "UNEXP CONN ELEMENT IN CTB" );
734 /*lint -fallthrough*/
735 case( MNCC_CONN_ELEM_NOT_PRES ): return( CRING_SERV_TYP_NotPresent );
736 }
737
738 case( MNCC_BEARER_SERV_ASYNC ):
739 switch( pBC -> conn_elem )
740 {
741 case( MNCC_CONN_ELEM_TRANS ): return( CRING_SERV_TYP_Async );
742 case( MNCC_CONN_ELEM_NON_TRANS ): return( CRING_SERV_TYP_RelAsync );
743 default: TRACE_EVENT( "UNEXP CONN ELEMENT IN CTB" );
744 /*lint -fallthrough*/
745 case( MNCC_CONN_ELEM_NOT_PRES ): return( CRING_SERV_TYP_NotPresent );
746 }
747
748 default: TRACE_EVENT( "UNEXP BEARER SERVICE IN CTB" );
749 /*lint -fallthrough*/
750 case( MNCC_BEARER_SERV_FAX ):
751 case( MNCC_BEARER_SERV_SPEECH_CTM ):
752 case( MNCC_BEARER_SERV_AUX_SPEECH_CTM):
753 case( MNCC_BEARER_SERV_SPEECH ):
754 case( MNCC_BEARER_SERV_AUX_SPEECH ):
755 case( MNCC_BEARER_SERV_PAD_ACCESS ):
756 case( MNCC_BEARER_SERV_PACKET_ACCESS ):
757 case( MNCC_BEARER_SERV_NOT_PRES ): return( CRING_SERV_TYP_NotPresent );
758
759 }
760 }
761
762 /*
763 +-------------------------------------------------------------------+
764 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
765 | ROUTINE : cmhCC_GetDataRate |
766 +-------------------------------------------------------------------+
767
768 PURPOSE : get user data rate out of bearer capabilities
769
770 */
771
772 GLOBAL SHORT cmhCC_GetDataRate ( void * bearCap )
773 {
774 T_MNCC_bcpara * pBC = (T_MNCC_bcpara*) bearCap;
775
776 switch( pBC->rate )
777 {
778 case( MNCC_UR_0_3_KBIT ): return( BS_SPEED_300_V110 );
779 case( MNCC_UR_1_2_KBIT ): return( BS_SPEED_1200_V110 );
780 case( MNCC_UR_2_4_KBIT ): return( BS_SPEED_2400_V110 );
781 case( MNCC_UR_4_8_KBIT ): return( BS_SPEED_4800_V110 );
782 case( MNCC_UR_9_6_KBIT ): return( BS_SPEED_9600_V110 );
783 case( MNCC_UR_14_4_KBIT ): return( BS_SPEED_14400_V110 );
784 default: return( BS_SPEED_NotPresent );
785 }
786
787 }
788
789 /*
790 +-------------------------------------------------------------------+
791 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
792 | ROUTINE : cmhCC_GetFormat |
793 +-------------------------------------------------------------------+
794
795 PURPOSE : get character format out of bearer capabilities
796
797 */
798
799 GLOBAL SHORT cmhCC_GetFormat ( void * bearCap )
800 {
801 T_MNCC_bcpara * pBC = (T_MNCC_bcpara*) bearCap;
802
803 if( pBC->data_bits EQ MNCC_DATA_7_BIT)
804 {
805 if( pBC->stop_bits EQ MNCC_STOP_1_BIT )
806 {
807 if( pBC->parity EQ MNCC_PARITY_NONE ) return( BS_FRM_Dat7_Par0_St1 );
808 else return( BS_FRM_Dat7_Par1_St1 );
809 }
810 else return( BS_FRM_Dat7_Par0_St2 );
811 }
812 else
813 {
814 if( pBC->stop_bits EQ MNCC_STOP_1_BIT )
815 {
816 if( pBC->parity EQ MNCC_PARITY_NONE ) return( BS_FRM_Dat8_Par0_St1 );
817 else return( BS_FRM_Dat8_Par1_St1 );
818 }
819 else return( BS_FRM_Dat8_Par0_St2 );
820 }
821 }
822
823
824 /*
825 +-------------------------------------------------------------------+
826 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
827 | ROUTINE : cmhCC_GetParity |
828 +-------------------------------------------------------------------+
829
830 PURPOSE : get parity out of bearer capabilities
831
832 */
833
834 GLOBAL SHORT cmhCC_GetParity ( void * bearCap )
835 {
836 T_MNCC_bcpara * pBC = (T_MNCC_bcpara*) bearCap;
837
838 switch( pBC->parity )
839 {
840 case( MNCC_PARITY_ODD ): return( BS_PAR_Odd );
841 case( MNCC_PARITY_EVEN ): return( BS_PAR_Even );
842 case( MNCC_PARITY_FORCED_TO_0 ): return( BS_PAR_Space );
843 case( MNCC_PARITY_FORCED_TO_1 ): return( BS_PAR_Mark );
844 case( MNCC_PARITY_NONE ):
845 default: return( BS_PAR_NotPresent );
846 }
847
848 }
849 #endif /* FAX_AND_DATA */
850 /*
851 +-------------------------------------------------------------------+
852 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
853 | ROUTINE : cmhCC_GetCallClass |
854 +-------------------------------------------------------------------+
855
856 PURPOSE : get call class out of bearer service
857
858 */
859
860 GLOBAL T_ACI_CLASS cmhCC_GetCallClass ( SHORT cId )
861 {
862 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
863
864 switch( ctb->BC[ctb->curBC].bearer_serv )
865 {
866 case( MNCC_BEARER_SERV_SPEECH_CTM ):
867 case( MNCC_BEARER_SERV_SPEECH ): return( CLASS_Vce );
868 case( MNCC_BEARER_SERV_AUX_SPEECH_CTM ):
869 case( MNCC_BEARER_SERV_AUX_SPEECH ): return( CLASS_AuxVce );
870 case( MNCC_BEARER_SERV_FAX ): return( CLASS_Fax );
871 case( MNCC_BEARER_SERV_SYNC ): return( CLASS_Dat );
872 case( MNCC_BEARER_SERV_ASYNC ): return( CLASS_Dat );
873 default: return( CLASS_NotPresent );
874 }
875
876 }
877
878 /*
879 +-------------------------------------------------------------------+
880 | PROJECT : GSM-PS (6147) MODULE : PSA_CCF |
881 | ROUTINE : cmhCC_ctbGetCldNumTyp |
882 +-------------------------------------------------------------------+
883
884 PURPOSE : this function builds the type of address information out
885 of the called party information.
886 */
887
888 GLOBAL T_ACI_TOA* cmhCC_ctbGetCldNumTyp ( SHORT cId, T_ACI_TOA* pToaBuf )
889 {
890 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
891 /*
892 *-------------------------------------------------------------------
893 * build type of address information
894 *-------------------------------------------------------------------
895 */
896 if (ctb->cldPty.ton EQ MNCC_TON_NOT_PRES )
897
898 return( NULL );
899
900 pToaBuf -> ton = (T_ACI_TOA_TON)ctb->cldPty.ton;
901 pToaBuf -> npi = (T_ACI_TOA_NPI)ctb->cldPty.npi;
902
903 return( pToaBuf );
904 }
905
906 /*
907 +-------------------------------------------------------------------+
908 | PROJECT : GSM-PS (6147) MODULE : PSA_CCF |
909 | ROUTINE : cmhCC_ctbGetCldSubTyp |
910 +-------------------------------------------------------------------+
911
912 PURPOSE : this function builds the type of subaddress information
913 out of the called party information.
914 */
915
916 GLOBAL T_ACI_TOS* cmhCC_ctbGetCldSubTyp ( SHORT cId, T_ACI_TOS * pTosBuf )
917 {
918 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
919 /*
920 *-------------------------------------------------------------------
921 * build type of subaddress information
922 *-------------------------------------------------------------------
923 */
924 if( ctb->cldPtySub.tos EQ MNCC_TOS_NOT_PRES )
925
926 return( NULL );
927
928 pTosBuf -> tos = (T_ACI_TOS_TOS)ctb->cldPtySub.tos;
929 pTosBuf -> oe = (T_ACI_TOS_OE)ctb->cldPtySub.odd_even;
930
931 return( pTosBuf );
932 }
933
934 /*
935 +-------------------------------------------------------------------+
936 | PROJECT : GSM-PS (6147) MODULE : PSA_CCF |
937 | ROUTINE : cmhCC_ctbGetClrNumTyp |
938 +-------------------------------------------------------------------+
939
940 PURPOSE : this function builds the type of address information out
941 of the calling party information.
942 */
943
944 GLOBAL T_ACI_TOA* cmhCC_ctbGetClrNumTyp ( SHORT cId, T_ACI_TOA* pToaBuf )
945 {
946 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
947 /*
948 *-------------------------------------------------------------------
949 * build type of address information
950 *-------------------------------------------------------------------
951 */
952 if (ctb->clgPty.ton EQ MNCC_TON_NOT_PRES )
953
954 return( NULL );
955
956 pToaBuf -> ton = (T_ACI_TOA_TON)ctb->clgPty.ton;
957 pToaBuf -> npi = (T_ACI_TOA_NPI)ctb->clgPty.npi;
958
959 return( pToaBuf );
960 }
961
962 /*
963 +-------------------------------------------------------------------+
964 | PROJECT : GSM-PS (6147) MODULE : PSA_CCF |
965 | ROUTINE : cmhCC_ctbGetClrSubTyp |
966 +-------------------------------------------------------------------+
967
968 PURPOSE : this function builds the type of subaddress information
969 out of the calling party information.
970 */
971
972 GLOBAL T_ACI_TOS* cmhCC_ctbGetClrSubTyp ( SHORT cId, T_ACI_TOS * pTosBuf )
973 {
974 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
975 /*
976 *-------------------------------------------------------------------
977 * build type of subaddress information
978 *-------------------------------------------------------------------
979 */
980 if( ctb->clgPtySub.tos EQ MNCC_TOS_NOT_PRES )
981
982 return( NULL );
983
984 pTosBuf -> tos = (T_ACI_TOS_TOS)ctb->clgPtySub.tos;
985 pTosBuf -> oe = (T_ACI_TOS_OE)ctb->clgPtySub.odd_even;
986
987 return( pTosBuf );
988 }
989
990 /*
991 +-------------------------------------------------------------------+
992 | PROJECT : GSM-PS (6147) MODULE : PSA_CCF |
993 | ROUTINE : cmhCC_ctbGetRdrNumTyp |
994 +-------------------------------------------------------------------+
995
996 PURPOSE : this function builds the type of address information out
997 of the redirecting party information.
998 */
999
1000 GLOBAL T_ACI_TOA* cmhCC_ctbGetRdrNumTyp ( SHORT cId, T_ACI_TOA* pToaBuf )
1001 {
1002 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1003 /*
1004 *-------------------------------------------------------------------
1005 * build type of address information
1006 *-------------------------------------------------------------------
1007 */
1008 if( ctb->rdrPty.ton EQ MNCC_TON_NOT_PRES )
1009
1010 return( NULL );
1011
1012 pToaBuf -> ton = (T_ACI_TOA_TON)ctb->rdrPty.ton;
1013 pToaBuf -> npi = (T_ACI_TOA_NPI)ctb->rdrPty.npi;
1014
1015 return( pToaBuf );
1016 }
1017
1018 /*
1019 +-------------------------------------------------------------------+
1020 | PROJECT : GSM-PS (6147) MODULE : PSA_CCF |
1021 | ROUTINE : cmhCC_ctbGetRdrSubTyp |
1022 +-------------------------------------------------------------------+
1023
1024 PURPOSE : this function builds the type of subaddress information
1025 out of the redirecting party information.
1026 */
1027
1028 GLOBAL T_ACI_TOS* cmhCC_ctbGetRdrSubTyp ( SHORT cId, T_ACI_TOS * pTosBuf )
1029 {
1030 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1031 /*
1032 *-------------------------------------------------------------------
1033 * build type of subaddress information
1034 *-------------------------------------------------------------------
1035 */
1036 if( ctb->rdrPtySub.tos EQ MNCC_TOS_NOT_PRES )
1037
1038 return( NULL );
1039
1040 pTosBuf -> tos = (T_ACI_TOS_TOS)ctb->rdrPtySub.tos;
1041 pTosBuf -> oe = (T_ACI_TOS_OE)ctb->rdrPtySub.odd_even;
1042
1043 return( pTosBuf );
1044 }
1045
1046 /*
1047 +-------------------------------------------------------------------+
1048 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
1049 | ROUTINE : cmhrat_no_carrier |
1050 +-------------------------------------------------------------------+
1051
1052 PURPOSE : Send NO CARRIER to user (saves memory in comparaison to R_AT).
1053 It also send a log to MFW, and sends NO CARRIER to the owner
1054 of the call if it is necessary (owner different from call killer).
1055
1056 It also sends a DCD off to UART.
1057
1058 */
1059
1060 GLOBAL void cmhrat_calldisc( RAT_ID response, UBYTE srcId, T_ACI_AT_CMD cmdId, SHORT cId )
1061 {
1062 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1063
1064 TRACE_FUNCTION("cmhrat_calldisc");
1065
1066 /* CHECK response: THIS ONLY WORKS BECAUSE R_AT has the same parameters
1067 for RAT_NO_CARRIER, RAT_BUSY and RAT_NO_ANSWER */
1068 switch( response )
1069 {
1070 case( RAT_NO_CARRIER ):
1071 case( RAT_BUSY ):
1072 case( RAT_NO_ANSWER ):
1073 break;
1074 default:
1075 return;
1076 }
1077
1078 if( srcId EQ (UBYTE)CMD_SRC_NONE OR
1079 srcId EQ ctb->calOwn )
1080 {
1081 /* inform only call owner */
1082
1083 R_AT( response, (T_ACI_CMD_SRC)ctb->calOwn ) ( AT_CMD_NONE, cId+1 );
1084 }
1085 else
1086 {
1087 /* inform both call owner and call killer */
1088 R_AT( response, (T_ACI_CMD_SRC)ctb->calOwn ) ( AT_CMD_NONE, cId+1 );
1089 R_AT( response, (T_ACI_CMD_SRC)srcId ) ( cmdId, cId+1 );
1090 }
1091
1092 #ifdef FF_ATI
1093 /* tlu:io_setDCD (ctb->calOwn, IO_DCD_OFF); */ /* V.24 DCD Line */
1094 #endif
1095
1096 cmh_logRslt ( (T_ACI_CMD_SRC)srcId, response, cmdId, (SHORT)(cId+1),
1097 BS_SPEED_NotPresent,CME_ERR_NotPresent);
1098 }
1099
1100 /*
1101 +-------------------------------------------------------------------+
1102 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
1103 | ROUTINE : cmhCC_SndDiscRsn |
1104 +-------------------------------------------------------------------+
1105
1106 PURPOSE : Find out the reason for disconnection and send it to the
1107 caller.
1108
1109 */
1110
1111 GLOBAL void cmhCC_SndDiscRsn ( SHORT cId )
1112 {
1113 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1114 UBYTE cmdBuf; /* buffers current command */
1115 UBYTE srcBuf; /* buffers current command source */
1116
1117 TRACE_FUNCTION ("cmhCC_SndDiscRsn()");
1118
1119 cmdBuf = ctb->curCmd;
1120 srcBuf = ctb->curSrc;
1121
1122 if (rdlPrm.rdlcId EQ NO_ENTRY)
1123 {
1124 cmhCC_PrepareCmdEnd (cId, NULL, NULL);
1125 }
1126
1127 if( cmdBuf EQ AT_CMD_NONE )
1128 {
1129 srcBuf = ctb->calOwn; /* call owner is the only one that
1130 could possibly be informed */
1131 }
1132
1133 if( cmdBuf EQ AT_CMD_ABRT )
1134 {
1135 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf )( cmdBuf );
1136 /* log result */
1137 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_OK,
1138 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1), BS_SPEED_NotPresent,CME_ERR_NotPresent );
1139 return;
1140 }
1141
1142 /*
1143 *-------------------------------------------------------------------
1144 * check for reject cause
1145 *-------------------------------------------------------------------
1146 */
1147 /*
1148 * Make use of ctb here or die. Problem with TI compiler 1.22e.
1149 * Seen. Exactly here. GET_CAUSE_VALUE() expression seems to become too
1150 * complicated without the help of this variable. You may get a wrong
1151 * ARM instruction otherwise in the generated code.
1152 */
1153 if(GET_CAUSE_VALUE(ctb->rejCs) NEQ NOT_PRESENT_8BIT)
1154 {
1155 /* when there is no SIM error, send the NO CARRIER command,
1156 otherwise cmhSIM_GetSIMError send the error command (CME) */
1157 if (GET_CAUSE_ORIGIN_ENTITY(ctb->rejCs) NEQ SIM_ORIGINATING_ENTITY OR
1158 cmhSIM_GetSIMError((T_ACI_CMD_SRC)srcBuf, (T_ACI_AT_CMD)cmdBuf) EQ AT_FAIL )
1159 {
1160 cmhrat_calldisc(RAT_NO_CARRIER, srcBuf, (T_ACI_AT_CMD)cmdBuf, cId);
1161 return;
1162 }
1163 else
1164 {
1165 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_CME,
1166 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1), BS_SPEED_NotPresent,CME_ERR_NotPresent );
1167 }
1168 return;
1169 }
1170
1171 /*
1172 *-------------------------------------------------------------------
1173 * otherwise check for normal cause
1174 *-------------------------------------------------------------------
1175 */
1176 switch( ctb->nrmCs )
1177 {
1178 case( MNCC_CAUSE_USER_BUSY ):
1179 cmhrat_calldisc(RAT_BUSY, srcBuf, (T_ACI_AT_CMD)cmdBuf, cId);
1180 break;
1181
1182 case( MNCC_CAUSE_NO_RESPONSE ):
1183 case( MNCC_CAUSE_ALERT_NO_ANSWER ):
1184 cmhrat_calldisc(RAT_NO_ANSWER, srcBuf, (T_ACI_AT_CMD)cmdBuf, cId);
1185 break;
1186
1187 default:
1188 cmhrat_calldisc(RAT_NO_CARRIER, srcBuf, (T_ACI_AT_CMD)cmdBuf, cId);
1189 }
1190 }
1191
1192 /*
1193 +-------------------------------------------------------------------+
1194 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
1195 | ROUTINE : cmhCC_ChckInCallMdfy |
1196 +-------------------------------------------------------------------+
1197
1198 PURPOSE : check the case of in-call modification. The function
1199 returns TRUE or FALSE, whether a modification is allowed
1200 or not.
1201
1202 */
1203
1204 GLOBAL BOOL cmhCC_ChckInCallMdfy ( SHORT cId, UBYTE cmd )
1205 {
1206 #ifdef FAX_AND_DATA
1207 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
1208
1209 TRACE_FUNCTION ("cmhCC_ChckInCallMdfy()");
1210
1211 #ifdef CO_UDP_IP
1212 if(calltype EQ UDPIP_CALL)
1213 {
1214 /* modifying a Wap Call should not be allowed */
1215 return( FALSE);
1216 }
1217 #endif /* CO_UDP_IP */
1218
1219 /* check call mode */
1220 switch( psaCC_ctb(cId)->rptInd )
1221 {
1222 /* single call */
1223 case( MNCC_RI_NOT_PRES ):
1224 return( FALSE );
1225
1226 /* voice followed by data */
1227 case( MNCC_RI_SEQUENTIAL ):
1228 if(calltype EQ VOICE_CALL)
1229 {
1230 switch( cmd )
1231 {
1232 case( AT_CMD_D ): /* modify commands */
1233 case( AT_CMD_A ):
1234
1235 TRACE_EVENT( "MODIFY FROM SPEECH" );
1236 return( TRUE );
1237 }
1238 }
1239 return( FALSE );
1240
1241 /* alternating call */
1242 case( MNCC_RI_CIRCULAR ):
1243 switch(calltype)
1244 {
1245 case(VOICE_CALL):
1246 switch( cmd )
1247 {
1248 case( AT_CMD_D ): /* modify commands */
1249 case( AT_CMD_A ):
1250
1251 TRACE_EVENT( "MODIFY FROM SPEECH" );
1252 return( TRUE );
1253 }
1254 return( FALSE );
1255
1256 case( TRANS_CALL ):
1257 case( NON_TRANS_CALL ):
1258 case( FAX_CALL ):
1259 if(cmd EQ AT_CMD_H ) /* modify commands */
1260 {
1261 TRACE_EVENT( "MODIFY FROM DATA/FAX" );
1262 return( TRUE );
1263 }
1264 break;
1265 }
1266 return( FALSE );
1267 }
1268 #endif /* FAX_AND_DATA */
1269 return(FALSE);
1270 }
1271
1272 /*
1273 +-------------------------------------------------------------------+
1274 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
1275 | ROUTINE : cmhCC_atdsendok |
1276 +-------------------------------------------------------------------+
1277
1278 PURPOSE : returns TRUE if OK is to be sent directly: in case of ATD,
1279 if COLP is not set and source is neither LCL nor SAT nor CSSN ...
1280 */
1281
1282 GLOBAL BOOL cmhCC_atdsendok ( SHORT cId )
1283 {
1284 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
1285 T_ACI_AT_CMD cmd = (T_ACI_AT_CMD)psaCC_ctb(cId)->curCmd;
1286 SHORT srcId = psaCC_ctb(cId)->curSrc;
1287
1288 #ifdef FF_ATI
1289 TRACE_EVENT_P6("cmhCC_atdsendok(): cmd: %d, calltype: %d, srcId: %d, COLP_stat: %d, SATinv: %d, CSSI_stat: %d",
1290 cmd, calltype, srcId, at.flags.COLP_stat, psaCC_ctb(cId)->SATinv,
1291 ati_user_output_cfg[srcId].CSSI_stat);
1292 #endif /* FF_ATI */
1293
1294 #ifdef FF_ATI
1295 if(cmd NEQ AT_CMD_D) /* can happen ONLY to ATD */
1296 return(FALSE);
1297
1298 if (calltype NEQ VOICE_CALL OR
1299 srcId EQ CMD_SRC_LCL OR
1300 at.flags.COLP_stat EQ 1 OR
1301 ati_user_output_cfg[srcId].CSSI_stat EQ 1 OR
1302 ati_is_src_type((UBYTE)srcId, ATI_SRC_TYPE_SAT) OR /* SAT run at cmd */
1303 psaCC_ctb(cId)->SATinv ) /* call started by SAT */
1304 {
1305 TRACE_EVENT("send OK normally: at the end");
1306 return(FALSE); /* OK sent normally: after MNCC_SETUP_CNF has been received */
1307 }
1308 else
1309 {
1310 TRACE_EVENT("send OK directly after ATD");
1311 return(TRUE); /* OK sent as soon as MNCC_SETUP_REQ has been sent (see ITU. V25ter) */
1312 }
1313 #else
1314 return(FALSE);
1315 #endif /* AT INTERPRETER */
1316
1317 }
1318
1319 /*
1320 +-------------------------------------------------------------------+
1321 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
1322 | ROUTINE : cmhCC_flagCall |
1323 +-------------------------------------------------------------------+
1324
1325 PURPOSE : flag a call for multy-call operation
1326
1327 */
1328
1329 GLOBAL void cmhCC_flagCall ( SHORT cId, USHORT * flags )
1330 {
1331 *flags |= (0x1 << cId);
1332 }
1333
1334 /*
1335 +-------------------------------------------------------------------+
1336 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
1337 | ROUTINE : cmhCC_tstAndUnflagCall |
1338 +-------------------------------------------------------------------+
1339
1340 PURPOSE : test and unflag a call for multy-call operation. Return
1341 the test result.
1342
1343 */
1344
1345 GLOBAL BOOL cmhCC_tstAndUnflagCall ( SHORT cId, USHORT * flags )
1346 {
1347 if( *flags & (1u << cId))
1348 {
1349 *flags &= ~(1u << cId);
1350 return( TRUE );
1351 }
1352 return( FALSE );
1353 }
1354
1355
1356 /*
1357 +-------------------------------------------------------------------+
1358 | PROJECT : GSM-PS (6147) MODULE : CMH_CC |
1359 | ROUTINE : cmhCC_getcalltype |
1360 +-------------------------------------------------------------------+
1361
1362 PURPOSE : returns the type of call of cId (voice, data, fax...).
1363
1364 */
1365
1366 GLOBAL T_CC_CALL_TYPE cmhCC_getcalltype(SHORT cId)
1367 {
1368 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1369
1370 /* First the call table is checked before the checking for the valid CID */
1371 if (ctb EQ NULL)
1372 return (T_CC_CALL_TYPE)ccShrdPrm.callType[cId]; /* Call already gone */
1373
1374 /* Check whether the cId is valid or not, if not return NO_VLD_CC_CALL_TYPE */
1375 if (!psaCC_ctbIsValid (cId))
1376 return(NO_VLD_CC_CALL_TYPE);
1377
1378 /* determine type of call */
1379 switch( ctb->BC[ctb->curBC].bearer_serv )
1380 {
1381 default:
1382 return(NO_VLD_CC_CALL_TYPE);
1383
1384 case( MNCC_BEARER_SERV_AUX_SPEECH ):
1385 case( MNCC_BEARER_SERV_SPEECH ): /* voice call */
1386 case( MNCC_BEARER_SERV_AUX_SPEECH_CTM ):
1387 case( MNCC_BEARER_SERV_SPEECH_CTM ): /* voice call with CTM */
1388 return(VOICE_CALL);
1389
1390 #ifdef FAX_AND_DATA
1391 case( MNCC_BEARER_SERV_ASYNC ): /* asynchronous data call */
1392 switch( ctb->BC[ctb->curBC].conn_elem )
1393 {
1394 case( MNCC_CONN_ELEM_TRANS ): /* transparent data call */
1395 case( MNCC_CONN_ELEM_NON_TRANS ): /* non transparent data call */
1396 /* check if a WAP call is in process... If yes then end call */
1397 #if defined(CO_UDP_IP) OR defined(FF_GPF_TCPIP)
1398 if (Wap_Call)
1399 {
1400 if (cId EQ wapId)
1401 {
1402 if(is_gpf_tcpip_call()) {
1403 GPF_TCPIP_STATEMENT(return(TCPIP_CALL));
1404 }
1405 else {
1406 UDPIP_STATEMENT(return(UDPIP_CALL));
1407 }
1408 }
1409 }
1410 #endif /* CO_UDP_IP || FF_GPF_TCPIP */
1411 #ifdef FF_PPP
1412 if (pppShrdPrm.is_PPP_CALL EQ TRUE)
1413 {
1414 return (PPP_CALL);
1415 }
1416 #endif
1417 if( ctb->BC[ctb->curBC].conn_elem EQ MNCC_CONN_ELEM_TRANS )
1418 {
1419 return(TRANS_CALL);
1420 }
1421 else
1422 return(NON_TRANS_CALL);
1423 }
1424 return(NO_VLD_CC_CALL_TYPE);
1425
1426 case( MNCC_BEARER_SERV_FAX ): /* fax call */
1427 return(FAX_CALL);
1428
1429 case( MNCC_BEARER_SERV_SYNC ):
1430 case( MNCC_BEARER_SERV_PAD_ACCESS ):
1431 case( MNCC_BEARER_SERV_PACKET_ACCESS ):
1432 return(UNSUP_DATA_CALL);
1433 #endif /* of #ifdef FAX_AND_DATA */
1434 }
1435 }
1436
1437 /*
1438 +-------------------------------------------------------------------+
1439 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
1440 | ROUTINE : cmhCC_AcceptCall |
1441 +-------------------------------------------------------------------+
1442
1443 PURPOSE : accept a call.
1444 */
1445
1446 GLOBAL void cmhCC_AcceptCall(SHORT cId, T_ACI_CMD_SRC srcId, T_ACI_AT_CMD cmd)
1447 {
1448 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1449 UBYTE idx; /* holds index value */
1450
1451 TRACE_FUNCTION("cmhCC_AcceptCall( )");
1452
1453 if (ctb EQ NULL OR ctb->calStat NEQ CS_ACT_REQ)
1454 {
1455 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_Unknown );
1456 R_AT(RAT_CME, srcId)(cmd, CME_ERR_Unknown);
1457 return;
1458 }
1459
1460 CHLDaddInfo = NO_CHLD_ADD_INFO;
1461 ctb->curCmd = cmd;
1462 ctb->calOwn = (T_OWN) srcId;
1463 ctb->curSrc = srcId;
1464
1465 /*
1466 * ETSI 11.10 26.12.4 requires "that for speech calls, the mobile station
1467 * shall attach the user connection at latest when sending the connect
1468 * message, except if there is no compatible radio resource available at
1469 * this time."
1470 */
1471
1472 psaCC_phbAddNtry ( LRN, cId, CT_MTC, NULL ); /* add call to LRN PB */
1473
1474 #ifdef FF_ATI
1475 io_setRngInd ( IO_RING_OFF, CRING_SERV_TYP_NotPresent, CRING_SERV_TYP_NotPresent ); /* V.24 Ring Indicator Line */
1476 #endif
1477
1478 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
1479 {
1480 R_AT( RAT_CRING_OFF,(T_ACI_CMD_SRC) idx )( cId+1 );
1481 }
1482
1483 psaCC_AcceptCall(cId);
1484 }
1485
1486 /*
1487 +-------------------------------------------------------------------+
1488 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
1489 | ROUTINE : cmhCC_RetrieveCall |
1490 +-------------------------------------------------------------------+
1491
1492 PURPOSE : Retrieve either a Multyparty or a Normal Call
1493 */
1494 GLOBAL void cmhCC_RetrieveCall(SHORT cId, T_ACI_CMD_SRC srcId)
1495 {
1496 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1497
1498 TRACE_FUNCTION("cmhCC_RetrieveCall( )");
1499
1500 if (ctb EQ NULL OR ctb->calStat NEQ CS_HLD)
1501 {
1502 return;
1503 }
1504
1505 CHLDaddInfo = NO_CHLD_ADD_INFO;
1506 ctb->curCmd = AT_CMD_CHLD;
1507 ctb->curSrc = srcId;
1508
1509 if (ctb->mptyStat EQ CS_ACT )
1510 {
1511 psaCC_Hold_RetrieveMPTY (cId, CS_HLD, CS_ACT_REQ, MNCC_MPTY_RETRIEVE_SENT,
1512 OPC_RETRIEVE_MPTY);
1513 }
1514 else
1515 {
1516 psaCC_RetrieveCall (cId);
1517 }
1518 }
1519
1520 /*
1521 +-------------------------------------------------------------------+
1522 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
1523 | ROUTINE : cmhCC_NewCall |
1524 +-------------------------------------------------------------------+
1525
1526 PURPOSE : Initiate a new call.
1527 */
1528 GLOBAL void cmhCC_NewCall(SHORT cId, T_ACI_CMD_SRC srcId, T_ACI_AT_CMD cmd)
1529 {
1530 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1531
1532 TRACE_FUNCTION("cmhCC_NewCall( )");
1533
1534 CHLDaddInfo = NO_CHLD_ADD_INFO;
1535 ctb->curCmd = cmd;
1536 ctb->calOwn = (T_OWN)srcId;
1537 ctb->curSrc = srcId;
1538
1539 psaCC_NewCall(cId);
1540 }
1541
1542 /*
1543 +-------------------------------------------------------------------+
1544 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
1545 | ROUTINE : cmhCC_HoldCall |
1546 +-------------------------------------------------------------------+
1547
1548 PURPOSE : Put a call on hold (multyparty or normal call)
1549 */
1550 GLOBAL void cmhCC_HoldCall(SHORT cId, T_ACI_CMD_SRC srcId, T_ACI_AT_CMD cmd)
1551 {
1552 T_CC_CALL_TBL *ctb; /* points to CC call table */
1553 T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
1554
1555 TRACE_FUNCTION("cmhCC_HoldCall( )");
1556
1557 ctb = ccShrdPrm.ctb[cId];
1558 pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
1559
1560 cmhCC_flagCall( cId, &(pCCCmdPrm->mltyCncFlg));
1561 ctb->curCmd = cmd;
1562 ctb->curSrc = srcId;
1563
1564 if (ctb->mptyStat EQ CS_ACT)
1565 {
1566 psaCC_Hold_RetrieveMPTY (cId, CS_ACT, CS_HLD_REQ, MNCC_MPTY_HOLD_SENT,
1567 OPC_HOLD_MPTY);
1568 }
1569 else
1570 {
1571 psaCC_HoldCall(cId);
1572 }
1573 }
1574 /*
1575 +-------------------------------------------------------------------+
1576 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
1577 | ROUTINE : cmhCC_ClearCall |
1578 +-------------------------------------------------------------------+
1579
1580 PURPOSE : disconnect a call.
1581 */
1582
1583 GLOBAL void cmhCC_ClearCall ( SHORT cId,
1584 USHORT cs,
1585 T_ACI_CMD_SRC srcId,
1586 UBYTE cmd,
1587 SHORT *waitId )
1588 {
1589 T_CC_CMD_PRM *pCCCmdPrm = NULL; /* points to CC command parameters */
1590 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
1591 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1592
1593 TRACE_FUNCTION( "cmhCC_ClearCall()" );
1594
1595 if(srcId > CMD_SRC_NONE AND
1596 srcId < CMD_SRC_MAX)
1597 {
1598 pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
1599 }
1600
1601 if (ccShrdPrm.ctb[cId] EQ NULL)
1602 {
1603 TRACE_EVENT("cmhCC_ClearCall(): Not a valid cId");
1604 return;
1605 }
1606
1607 TRACE_EVENT_P2("Clear Call ==> calStat: %d, calType: %d", ctb->calStat, ctb->calType NEQ CT_MOC);
1608
1609 if(cmd NEQ AT_CMD_NONE) /* for instance +CHUP / H / Z */
1610 {
1611 /* Check whether an incoming call is rejected by the user. */
1612 if( ctb->calStat EQ CS_ACT_REQ AND
1613 ctb->calType EQ CT_MTC)
1614 {
1615 psaCC_phbAddNtry ( LRN, cId, CT_MTC, NULL ); /* Add call to Last Received Number (LRN) PB */
1616 }
1617
1618 /* Check whether call is a waiting call */
1619 if(waitId NEQ NULL)
1620 {
1621 if( ctb->calStat EQ CS_ACT_REQ AND
1622 ctb->calType EQ CT_MTC AND
1623 ctb->calOwn EQ ((T_OWN)CMD_SRC_NONE) )
1624 {
1625 /* tag a found waiting call */
1626 TRACE_EVENT_P1("Waiting Call Found ! waitId=%d", cId);
1627 *waitId = cId;
1628 return;
1629 }
1630 }
1631 }
1632
1633 ccShrdPrm.cIdFail = cId;
1634 if ( cmd NEQ AT_CMD_NONE ) /* this will decide whether a result is sent to the user or not */
1635 {
1636 /* ATZ and ATH or AT+CHUP for instance */
1637 if(pCCCmdPrm NEQ NULL)
1638 {
1639 cmhCC_flagCall( cId, &(pCCCmdPrm -> mltyDscFlg));
1640 }
1641 ctb->curCmd = cmd;
1642 ctb->curSrc = srcId;
1643 }
1644 else
1645 {
1646 /* AOC for instance */
1647 cmhCC_SndDiscRsn(cId);
1648 }
1649 ctb->nrmCs = cs;
1650
1651 /* determine call status */
1652 switch( ctb->calStat )
1653 {
1654 /* active calls */
1655 case( CS_ACT ):
1656 switch( calltype )
1657 {
1658 case( VOICE_CALL ):
1659 psaCC_ClearCall (cId);
1660 break;
1661
1662 #if defined FAX_AND_DATA AND defined (DTI)
1663
1664 case( TRANS_CALL ):
1665 ccShrdPrm.datStat = DS_DSC_REQ;
1666 cmhTRA_Deactivate ();
1667 break;
1668
1669 case( NON_TRANS_CALL ):
1670 ccShrdPrm.datStat = DS_DSC_REQ;
1671 cmhL2R_Deactivate ();
1672 break;
1673
1674 #ifdef FF_FAX
1675 case( FAX_CALL ):
1676 ccShrdPrm.datStat = DS_DSC_REQ;
1677 cmhT30_Deactivate ();
1678 break;
1679 #endif /* FF_FAX */
1680
1681 #if defined(CO_UDP_IP) OR defined(FF_GPF_TCPIP)
1682
1683 #ifdef CO_UDP_IP
1684 case( UDPIP_CALL ):
1685 #endif
1686
1687 #ifdef FF_GPF_TCPIP
1688 case( TCPIP_CALL ):
1689 {
1690 T_DCM_STATUS_IND_MSG msg;
1691 msg.hdr.msg_id = DCM_ERROR_IND_MSG;
1692 msg.result = DCM_PS_CONN_BROKEN;
1693 dcm_send_message(msg, DCM_SUB_WAIT_SATDN_CNF);
1694 }
1695 #endif
1696 ccShrdPrm.datStat = DS_DSC_REQ;
1697 /* also test whether a SAT E connection has to be shut down */
1698 if ( (cmd NEQ AT_CMD_NONE)
1699 #ifdef FF_SAT_E
1700 OR (satShrdPrm.opchAcptSrc EQ srcId)
1701 #endif
1702 )
1703 {
1704 /* set the last possible state for the next "else if" statement */
1705 T_ACI_WAP_STATES last_state = Wap_Not_Init;
1706 if(is_gpf_tcpip_call()) {
1707 GPF_TCPIP_STATEMENT(last_state = TCPIP_Deactivation);
1708 }
1709 else {
1710 last_state = UDPA_Deactivation;
1711 }
1712
1713 /* Terminate PPP if established. UP indicate that entities under PPP are still activ. */
1714 if((pppShrdPrm.state EQ PPP_ESTABLISHED) OR
1715 (pppShrdPrm.state EQ PPP_ESTABLISH))
1716 {
1717 cmhPPP_Terminate(UP);
1718 }
1719 else if (wap_state > Wap_Not_Init AND
1720 wap_state <= last_state)
1721 {
1722 cmhPPP_Terminated(); /* Trigger termination of SCPIP if PPP did not yet start (ACI-FIX-9317) */
1723 }
1724 }
1725 break;
1726 #endif /* defined(CO_UDP_IP) OR defined(FF_GPF_TCPIP) */
1727 #if defined (FF_PPP) AND defined (DTI)
1728 case( PPP_CALL ):
1729 ccShrdPrm.datStat = DS_DSC_REQ;
1730 if (pppShrdPrm.is_PPP_CALL EQ TRUE)
1731 {
1732 dti_cntrl_close_dpath_from_src_id((UBYTE)srcId);
1733 }
1734 #endif /* DTI */
1735 #endif /* of #ifdef FAX_AND_DATA */
1736 default:
1737 TRACE_ERROR("Wrong call type");
1738 }
1739 break;
1740
1741 /* other present calls */
1742 case( CS_HLD ):
1743 case( CS_HLD_REQ ):
1744 case( CS_MDF_REQ ):
1745 case( CS_DSC_REQ ):
1746 case( CS_ACT_REQ ):
1747 case( CS_CPL_REQ ):
1748 psaCC_ClearCall (cId);
1749 break;
1750 }
1751 }
1752
1753 /*
1754 +--------------------------------------------------------------------+
1755 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
1756 | STATE : code ROUTINE : cmhCC_chkDTMFDig |
1757 +--------------------------------------------------------------------+
1758
1759 PURPOSE : This function is used extract DTMF digits from the dialled
1760 number. The DTMF digits, including separators, are stored
1761 in the DTMF parameters and will be send automatically after
1762 the connection is established.
1763 BOOL within_dial_string parameter to tell if DTMF tones are
1764 within a dial string or directly given.
1765 USHROT length: possibility to give the number of dtmf to be
1766 sent (relevant only if not within a dial string).
1767 */
1768
1769 /* next function fills up dtmf structure with extracted prms */
1770 LOCAL void cmhCC_fillDTMFDig ( SHORT cId, CHAR *dtmf, USHORT dtmf_length )
1771 {
1772 TRACE_FUNCTION("cmhCC_fillDTMFDig()");
1773
1774 if( dtmf NEQ NULL )
1775 {
1776 ccShrdPrm.dtmf.cnt = MINIMUM( dtmf_length, MAX_DTMF_DIG );
1777
1778 strncpy( (char *)ccShrdPrm.dtmf.dig, dtmf, ccShrdPrm.dtmf.cnt );
1779 ccShrdPrm.dtmf.dig[dtmf_length] = '\0';
1780
1781 ccShrdPrm.dtmf.cur = 0;
1782 ccShrdPrm.dtmf.cId = cId;
1783 TRACE_EVENT_P2("ccShrdPrm.dtmf.cnt: %d, ccShrdPrm.dtmf.cId: %d", ccShrdPrm.dtmf.cnt, ccShrdPrm.dtmf.cId);
1784 }
1785 else
1786 {
1787 ccShrdPrm.dtmf.cnt = 0;
1788 ccShrdPrm.dtmf.cur = 0;
1789 ccShrdPrm.dtmf.cId = NO_ENTRY;
1790 }
1791 }
1792
1793 GLOBAL BOOL is_digit_dtmf_separator(CHAR digit)
1794 {
1795 switch(digit)
1796 {
1797 case('P'): /* PHB_DIAL_PAUSE, PHB_DTMF_SEP */
1798 case('p'):
1799 case('W'): /* PHB_DIAL_WAIT */
1800 case('w'):
1801 TRACE_EVENT("DTMF Separator Found");
1802 return(TRUE);
1803 }
1804 return(FALSE);
1805 }
1806
1807 LOCAL CHAR * find_dtmf_separator(CHAR *number_string, USHORT length)
1808 {
1809 int i;
1810
1811 TRACE_FUNCTION("find_dtmf_separator()");
1812
1813 for(i=0; i<length; i++)
1814 {
1815 if(is_digit_dtmf_separator(*number_string))
1816 {
1817 return(number_string);
1818 }
1819 number_string++;
1820 }
1821 return(NULL);
1822 }
1823
1824 GLOBAL void cmhCC_chkDTMFDig ( CHAR* num,
1825 SHORT cId,
1826 USHORT length,
1827 BOOL within_dial_string )
1828 {
1829 CHAR *dtmf = num;
1830 USHORT len = length;
1831
1832 TRACE_FUNCTION("cmhCC_chkDTMFDig()");
1833
1834 if( within_dial_string )
1835 {
1836 dtmf = find_dtmf_separator(num, (USHORT)strlen(num)); /*strchr( num, PHB_DTMF_SEP ); */
1837
1838 if(dtmf NEQ NULL)
1839 {
1840 len = strlen(dtmf);
1841 TRACE_EVENT_P1("Call number string contains %d DTMF tones", len);
1842 }
1843 }
1844 else
1845 {
1846 /* already inialized for the case "not within a phone call" (e.g SAT Send DTMF) */
1847 }
1848
1849 cmhCC_fillDTMFDig ( cId, dtmf, len );
1850
1851 if(dtmf NEQ NULL)
1852 {
1853 *dtmf = '\0'; /* split dial string from DTMF tones */
1854 }
1855
1856 }
1857
1858 /*
1859 +--------------------------------------------------------------------+
1860 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
1861 | STATE : code ROUTINE : cmhCC_chkKeySeq |
1862 +--------------------------------------------------------------------+
1863
1864 PURPOSE : This function is used to decode a keystroke sequence and
1865 to initiate an appropriate action.
1866 */
1867 GLOBAL T_ACI_RETURN cmhCC_chkKeySeq ( T_ACI_CMD_SRC srcId,
1868 T_CLPTY_PRM *cldPty,
1869 T_ACI_D_TOC *callType,
1870 T_ACI_D_CLIR_OVRD *CLIRovrd,
1871 T_CC_SIM_QLF ccSIMQlf )
1872 {
1873 T_KSD_SEQGRP seqGrp = SEQGRP_UNKNOWN;
1874 T_KSD_SEQPARAM seqPrm;
1875 CHAR *restSeq = NULL;
1876 T_ACI_RETURN retVal;
1877 T_PHB_RECORD phbNtry;
1878 T_PHB_TYPE slctPHB;
1879 #ifdef SIM_TOOLKIT
1880 T_sat_ussd SATussd; /* to hold USSD string in case of SAT Control */
1881 #endif /* of SIM_TOOLKIT */
1882
1883 TRACE_FUNCTION ("cmhCC_chkKeySeq ()");
1884
1885 if( cldPty EQ NULL OR
1886 strlen (cldPty->num) EQ 0 )
1887 {
1888 return( AT_CMPL );
1889 }
1890
1891 restSeq = cldPty->num;
1892 seqGrp = SEQGRP_UNKNOWN;
1893
1894 #ifdef SIM_TOOLKIT
1895 /* check for SAT SIM Call Control of SS strings */
1896 if (ccSIMQlf EQ CC_SIM_YES)
1897 {
1898 if ( !ksd_isFDNCheckSeq ( cldPty-> num ) )
1899 ; /* bypass *#06# from SSCntrlBySIM */
1900 else
1901 {
1902 retVal = AT_CMPL; /* init */
1903 if( ksd_isSATSscs (cldPty->num) )
1904 {
1905 retVal = cmhSAT_SSCntrlBySIM( cldPty, (UBYTE)srcId );
1906 }
1907 else if( ksd_isUSSD (cldPty->num) )
1908 {
1909 if (psaSIM_ChkSIMSrvSup(SRV_USSDsupportInCC))
1910 {
1911 SATussd.dcs = 0x0F; /* default alphabet see GSM 03.38 Cell Broadcast dcs */
1912 SATussd.c_ussd_str = strlen(cldPty->num);
1913 SATussd.ussd_str = (UBYTE *)cldPty->num;
1914
1915 retVal = cmhSAT_USSDCntrlBySIM( &SATussd, (UBYTE)srcId );
1916 }
1917 else
1918 {
1919 retVal = cmhSAT_SSCntrlBySIM( cldPty, (UBYTE)srcId );
1920 }
1921 }
1922
1923 if( retVal NEQ AT_CMPL )
1924 return( retVal );
1925 }
1926 }
1927 #endif
1928
1929 /*
1930 *-------------------------------------------------------------
1931 * decode SS string
1932 *-------------------------------------------------------------
1933 */
1934 if (ksd_decode (cldPty->num,
1935 psaCC_ctbAnyCallInUse(), /* is there any call??? */
1936 &seqGrp,
1937 &restSeq,
1938 &seqPrm) EQ TRUE)
1939 {
1940 retVal = AT_FAIL;
1941
1942 /*
1943 *-------------------------------------------------------------
1944 * perform desired action
1945 *-------------------------------------------------------------
1946 */
1947 switch (seqGrp)
1948 {
1949 /*
1950 *---------------------------------------------------------
1951 * handling of sequence group SEQGRP_IMEI
1952 *---------------------------------------------------------
1953 */
1954 case ( SEQGRP_PRSNT_IMEI ):
1955 retVal = cmhSS_ksdIMEI( srcId );
1956 break;
1957
1958 /*
1959 *---------------------------------------------------------
1960 * handling of sequence group SEQGRP_DIAL
1961 *---------------------------------------------------------
1962 */
1963 case (SEQGRP_DIAL):
1964 strncpy(cldPty->num, seqPrm.dial.number, sizeof (cldPty->num) - 1);
1965 cldPty->num[sizeof(cldPty->num) - 1] = '\0';
1966 return ((T_ACI_RETURN) AT_CONT);
1967
1968 /*
1969 *---------------------------------------------------------
1970 * handling of sequence group SEQGRP_CHLD
1971 *---------------------------------------------------------
1972 */
1973 case (SEQGRP_CHLD):
1974 retVal = sAT_PlusCHLD( srcId, seqPrm.chld.mode, seqPrm.chld.call );
1975 if (retVal NEQ AT_FAIL)
1976 break; /* successfull CHLD */
1977
1978 /* else handle as USSD if this CHLD was unexpected/illegal */
1979
1980 seqPrm.ussd.ussd = (UBYTE *)cldPty->num;
1981 seqGrp = SEQGRP_USSD;
1982 restSeq = cldPty->num + strlen (cldPty->num);
1983 /* fallthrough */
1984 /*lint -fallthrough*/
1985 /*
1986 *---------------------------------------------------------
1987 * handling of sequence group SEQGRP_USSD
1988 *---------------------------------------------------------
1989 */
1990 case (SEQGRP_USSD):
1991 retVal = cmhSS_ksdUSSD( srcId, &seqPrm.ussd );
1992 break;
1993
1994 /*
1995 *---------------------------------------------------------
1996 * handling of sequence group SEQGRP_DIAL_IDX
1997 *---------------------------------------------------------
1998 */
1999 case (SEQGRP_DIAL_IDX):
2000
2001 if( !cmhPHB_cvtPhbType(cmhPrm[srcId].phbCmdPrm.cmhStor,
2002 &slctPHB ))
2003 return( AT_FAIL );
2004
2005 #ifdef TI_PS_FFS_PHB
2006 if (pb_read_record (slctPHB,
2007 seqPrm.dialIdx.index,
2008 &phbNtry) EQ PHB_OK)
2009 #else
2010 if( pb_read_phys_record( slctPHB, seqPrm.dialIdx.index, &phbNtry )
2011 EQ PHB_OK )
2012 #endif
2013 {
2014 cmhPHB_getAdrStr( cldPty->num, sizeof (cldPty->num) - 1,
2015 phbNtry.number, phbNtry.len );
2016
2017 cmh_demergeTOA ( phbNtry.ton_npi, &cldPty->ton, &cldPty->npi );
2018
2019 /*
2020 *---------------------------------------------------------
2021 * as long as the bearer capabilities are not read from
2022 * the phonebook only voice calls are supported
2023 *---------------------------------------------------------
2024 */
2025 *callType = D_TOC_Voice;
2026
2027 return((T_ACI_RETURN) AT_CONT);
2028 }
2029
2030 return( AT_FAIL );
2031
2032 /*
2033 *---------------------------------------------------------
2034 * handling of sequence groups which relates
2035 * to call forwarding parameter
2036 *---------------------------------------------------------
2037 */
2038 case (SEQGRP_CF):
2039 /* type of address has already been set,
2040 and a possible "+" already been removed... */
2041 if(seqPrm.cf.num NEQ NULL AND
2042 seqPrm.cf.num[0] NEQ 0) /* only set if there is actually a number */
2043 {
2044 seqPrm.cf.ton = cldPty->ton;
2045 seqPrm.cf.npi = cldPty->npi;
2046 }
2047 else
2048 {
2049 seqPrm.cf.ton = MNCC_TON_NOT_PRES;
2050 seqPrm.cf.npi = MNCC_NPI_NOT_PRES;
2051 }
2052
2053 /* subaddress has also already been split up if existing */
2054 if(cldPty->sub[0] NEQ 0)
2055 {
2056 seqPrm.cf.sub = (UBYTE *)cldPty->sub;
2057 seqPrm.cf.tos = cldPty->tos;
2058 seqPrm.cf.oe = cldPty->oe;
2059 }
2060 else
2061 seqPrm.cf.sub = NULL;
2062
2063 retVal = cmhSS_ksdCF( srcId, &seqPrm.cf );
2064 break;
2065
2066 /*
2067 *---------------------------------------------------------
2068 * handling of sequence groups which relates to
2069 * call barring parameter
2070 *---------------------------------------------------------
2071 */
2072 case (SEQGRP_CB):
2073 retVal = cmhSS_ksdCWCBStartTrans(srcId, KSD_CMD_CB, &seqPrm);
2074 break;
2075
2076 /*
2077 *---------------------------------------------------------
2078 * handling of sequence groups which results in a change
2079 * of CLIR parameter
2080 * in temporary mode a call is set up
2081 *---------------------------------------------------------
2082 */
2083
2084 case (SEQGRP_SUP_COLR):
2085 case (SEQGRP_INV_COLR):
2086 case (SEQGRP_SUP_COLP):
2087 case (SEQGRP_INV_COLP):
2088 case (SEQGRP_SUP_CLIP):
2089 case (SEQGRP_INV_CLIP):
2090 if (strlen (restSeq) EQ 0)
2091 {
2092 T_ACI_KSD_USSD_PRM ksdString;
2093
2094 ksdString.ussd = (UBYTE*)cldPty->num;
2095 retVal = cmhSS_ksdUSSD( srcId, &ksdString );
2096 }
2097 else
2098 {
2099 /*
2100 *-----------------------------------------------------
2101 * temporary mode nonexistant on CLIR, COLR and COLP!!
2102 * So ignore USSD and continue calling: "Number not assigned"
2103 * will be indicated to the user by the network
2104 * This is the common behaviour as found on other phones
2105 *-----------------------------------------------------
2106 */
2107 return((T_ACI_RETURN) AT_CONT);
2108 }
2109 break;
2110
2111 case (SEQGRP_SUP_CLIR):
2112 case (SEQGRP_INV_CLIR):
2113 if (strlen (restSeq) EQ 0)
2114 {
2115 #if defined(MFW) OR defined(FF_MMI_RIV)
2116 if (srcId EQ CMD_SRC_LCL) /* VO: temp solution because MFW uses sAT_Dn to set CLIR */
2117 retVal = sAT_PlusCLIR(srcId, seqPrm.Clir.mode);
2118 else
2119 #endif
2120 {
2121 T_ACI_KSD_USSD_PRM ksdString;
2122
2123 ksdString.ussd = (UBYTE*)cldPty->num;
2124 retVal = cmhSS_ksdUSSD( srcId, &ksdString );
2125 }
2126 }
2127 else
2128 {
2129 /*
2130 *-----------------------------------------------------
2131 * in temporary mode a call is set up
2132 *-----------------------------------------------------
2133 */
2134 T_KSD_CLIR Clir;
2135 T_KSD_SEQGRP nextGrp = SEQGRP_UNKNOWN;
2136 CHAR* remSeq = NULL;
2137
2138 Clir.mode = seqPrm.Clir.mode;
2139
2140 if (ksd_decode (restSeq, FALSE,
2141 &nextGrp, &remSeq,
2142 &seqPrm)
2143 AND
2144 nextGrp EQ SEQGRP_DIAL)
2145 {
2146 *CLIRovrd = (Clir.mode EQ CLIR_MOD_Supp)?
2147 D_CLIR_OVRD_Supp: D_CLIR_OVRD_Invoc;
2148 strncpy(cldPty->num, seqPrm.dial.number, sizeof(cldPty->num) - 1);
2149 cldPty->num[sizeof(cldPty->num) - 1] = '\0';
2150 return((T_ACI_RETURN) AT_CONT);
2151 }
2152 }
2153 break;
2154
2155 /*
2156 *---------------------------------------------------------
2157 * handling of sequence group for TTY service
2158 *---------------------------------------------------------
2159 */
2160 case (SEQGRP_TTY_SERV):
2161 if (strlen (restSeq) EQ 0)
2162 {
2163 #ifdef FF_TTY
2164 retVal = sAT_PercentCTTY (srcId, CTTY_MOD_NotPresent,
2165 seqPrm.ctty.req);
2166 #else
2167 retVal = AT_FAIL;
2168 #endif /* FF_TTY */
2169 }
2170 else
2171 {
2172 T_KSD_SEQGRP nextGrp = SEQGRP_UNKNOWN;
2173 CHAR* remSeq = NULL;
2174 #ifdef FF_TTY
2175 if (seqPrm.ctty.req EQ CTTY_REQ_Off
2176 AND ccShrdPrm.ctmReq EQ MNCC_CTM_ENABLED)
2177 {
2178 ccShrdPrm.ctmOvwr = TRUE;
2179 }
2180 else if (seqPrm.ctty.req EQ CTTY_REQ_On
2181 AND ccShrdPrm.ctmReq EQ MNCC_CTM_DISABLED)
2182 {
2183 ccShrdPrm.ctmOvwr = TRUE;
2184 }
2185 else
2186 {
2187 ccShrdPrm.ctmOvwr = FALSE;
2188 }
2189 #endif /* FF_TTY */
2190 if (ksd_decode (restSeq, FALSE,
2191 &nextGrp, &remSeq,
2192 &seqPrm)
2193 AND
2194 nextGrp EQ SEQGRP_DIAL)
2195 {
2196 strncpy(cldPty->num, seqPrm.dial.number, sizeof(cldPty->num) - 1);
2197 cldPty->num[sizeof(cldPty->num) - 1] = '\0';
2198 return((T_ACI_RETURN) AT_CONT);
2199 }
2200 }
2201 break;
2202
2203 /*
2204 *---------------------------------------------------------
2205 * handling of sequence group which relates to
2206 * calling line supplementary services
2207 *---------------------------------------------------------
2208 */
2209 case (SEQGRP_CL):
2210 retVal = cmhSS_ksdCL( srcId, &seqPrm.cl );
2211 break;
2212
2213 /*
2214 *---------------------------------------------------------
2215 * handling of sequence groups which results in a
2216 * registration of passwords
2217 *---------------------------------------------------------
2218 */
2219 case (SEQGRP_PWD):
2220 retVal = cmhSS_ksdPW( srcId, &seqPrm.pwd );
2221 break;
2222
2223 /*
2224 *---------------------------------------------------------
2225 * handling of sequence groups which results in a
2226 * registration of passwords
2227 *---------------------------------------------------------
2228 */
2229 case (SEQGRP_UBLK):
2230 retVal = cmhSS_ksdUBLK( srcId, &seqPrm.ublk );
2231 break;
2232
2233 /*
2234 *---------------------------------------------------------
2235 * handling of sequence groups which relates to
2236 * call waiting
2237 *---------------------------------------------------------
2238 */
2239 case (SEQGRP_CW):
2240 retVal = cmhSS_ksdCWCBStartTrans(srcId, KSD_CMD_CW, &seqPrm);
2241 break;
2242
2243 /*
2244 *---------------------------------------------------------
2245 * handling of sequence group SEQGRP_CCBS
2246 *---------------------------------------------------------
2247 */
2248 case (SEQGRP_CCBS):
2249 retVal = cmhSS_ksdCCBS( srcId, &seqPrm.ccbs );
2250 break;
2251
2252 /*
2253 *---------------------------------------------------------
2254 * handling of sequence group SEQGRP_UNKNOWN
2255 *---------------------------------------------------------
2256 */
2257 case (SEQGRP_UNKNOWN):
2258 TRACE_EVENT ("sequence group unknown");
2259 break;
2260 }
2261 }
2262 else
2263 {
2264 TRACE_EVENT ("ksd_decode failed");
2265 return( AT_FAIL );
2266 }
2267
2268 return( retVal );
2269 }
2270
2271 /*
2272 +--------------------------------------------------------------------+
2273 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
2274 | STATE : code ROUTINE : cmhCC_fillSetupPrm |
2275 +--------------------------------------------------------------------+
2276
2277 PURPOSE : This function fills the call table entry with the
2278 necessary setup parameters.
2279 */
2280
2281 GLOBAL T_ACI_RETURN cmhCC_fillSetupPrm ( SHORT cId,
2282 T_ACI_CMD_SRC srcId,
2283 T_CLPTY_PRM *cldPty,
2284 T_MNCC_bcpara *bc,
2285 UBYTE prio,
2286 T_ACI_D_CLIR_OVRD clirOvrd,
2287 T_ACI_D_CUG_CTRL cugCtrl,
2288 T_ACI_D_TOC callType )
2289 {
2290 T_CC_CALL_TBL *pfilled_ctb;
2291 T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
2292 #ifdef FF_FAX
2293 T_T30_CMD_PRM *pT30CmdPrm; /* points to T30 command parameters */
2294 #endif
2295
2296 TRACE_FUNCTION ("cmhCC_fillSetupPrm()");
2297
2298 /* initializing local pointers: */
2299 pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
2300
2301 #ifdef FF_FAX
2302 pT30CmdPrm = &fnd_cmhPrm[srcId].t30CmdPrm;
2303 #endif
2304
2305 pfilled_ctb = ccShrdPrm.ctb[cId];
2306
2307 /*
2308 *-----------------------------------------------------------------
2309 * check data capabilities
2310 *-----------------------------------------------------------------
2311 */
2312 #ifndef FAX_AND_DATA
2313 if( callType NEQ D_TOC_Voice )
2314 {
2315 TRACE_EVENT("No data calls supported");
2316 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_NoDataCallSup );
2317 return( AT_FAIL ); /* no data calls allowed */
2318 }
2319 #endif /* of #ifndef FAX_AND_DATA */
2320
2321 /*
2322 *-----------------------------------------------------------------
2323 * called address
2324 *-----------------------------------------------------------------
2325 */
2326 if( cldPty EQ NULL )
2327 {
2328 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
2329 return( AT_FAIL ); /* no number */
2330 }
2331
2332 /* priority */
2333 pfilled_ctb->prio = prio;
2334
2335 if ((prio EQ MNCC_PRIO_NORM_CALL) AND
2336 (aoc_check_moc() EQ FALSE))
2337 /*
2338 * check ACM exceeds ACMmax
2339 * for non-emergency calls
2340 */
2341 {
2342 ACI_ERR_DESC( ACI_ERR_CLASS_Ceer, CAUSE_MAKE(DEFBY_STD,
2343 ORIGSIDE_MS, MNCC_ACI_ORIGINATING_ENTITY, CEER_ACM_Max ));
2344 return( AT_FAIL );
2345 }
2346
2347 /* subaddress */
2348 pfilled_ctb->cldPtySub.tos = cldPty->tos;
2349 pfilled_ctb->cldPtySub.odd_even = cldPty->oe;
2350 pfilled_ctb->cldPtySub.c_subaddr
2351 = (UBYTE)utl_dialStr2BCD (cldPty->sub,
2352 pfilled_ctb->cldPtySub.subaddr,
2353 MNCC_SUB_LENGTH);
2354
2355 /* address */
2356 if( pCCCmdPrm -> CSTAdef NEQ TRUE )
2357 {
2358 pfilled_ctb->cldPty.npi = pCCCmdPrm -> CSTAtoa.npi;
2359 pfilled_ctb->cldPty.ton = pCCCmdPrm -> CSTAtoa.ton;
2360 }
2361 else
2362 {
2363 pfilled_ctb->cldPty.npi = cldPty->npi;
2364 pfilled_ctb->cldPty.ton = cldPty->ton;
2365 }
2366
2367 if (pfilled_ctb->cldPty.called_num NEQ NULL)
2368 {
2369 ACI_MFREE (pfilled_ctb->cldPty.called_num);
2370 pfilled_ctb->cldPty.called_num = NULL;
2371 }
2372 pfilled_ctb->cldPty.c_called_num =
2373 (UBYTE)utl_dialStr2BCD (cldPty->num, NULL, MNCC_MAX_CC_CALLED_NUMBER);
2374 if (pfilled_ctb->cldPty.c_called_num NEQ 0)
2375 {
2376 ACI_MALLOC (pfilled_ctb->cldPty.called_num,
2377 pfilled_ctb->cldPty.c_called_num);
2378 (void)utl_dialStr2BCD (cldPty->num,
2379 pfilled_ctb->cldPty.called_num,
2380 pfilled_ctb->cldPty.c_called_num);
2381 }
2382
2383 psaCC_phbSrchNum( cId, CT_MOC); /* get alpha identifier */
2384
2385 /*
2386 *-----------------------------------------------------------------
2387 * CLIR setting
2388 *-----------------------------------------------------------------
2389 */
2390 switch( clirOvrd )
2391 {
2392 case( D_CLIR_OVRD_Supp ):
2393 pfilled_ctb->CLIRsup = MNCC_CLR_SUP;
2394 break;
2395
2396 case( D_CLIR_OVRD_Invoc ):
2397 pfilled_ctb->CLIRsup = MNCC_CLR_SUP_NOT;
2398 break;
2399
2400 case( D_CLIR_OVRD_Default ):
2401
2402 switch( pCCCmdPrm -> CLIRmode )
2403 {
2404 case( CLIR_MOD_Subscript ):
2405 pfilled_ctb->CLIRsup = MNCC_CLR_NOT_PRES;
2406 break;
2407 case( CLIR_MOD_Invoc ):
2408 pfilled_ctb->CLIRsup = MNCC_CLR_SUP_NOT;
2409 break;
2410 case( CLIR_MOD_Supp ):
2411 pfilled_ctb->CLIRsup = MNCC_CLR_SUP;
2412 break;
2413 }
2414 break;
2415
2416 default:
2417 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
2418 return( AT_FAIL );
2419 }
2420
2421 /*
2422 *-----------------------------------------------------------------
2423 * CUG setting
2424 *-----------------------------------------------------------------
2425 */
2426 if ( cugCtrl EQ D_CUG_CTRL_Present OR
2427 pCCCmdPrm -> CCUGmode EQ CCUG_MOD_EnableTmp )
2428 {
2429 pfilled_ctb->CUGidx = pCCCmdPrm -> CCUGidx;
2430
2431 switch( pCCCmdPrm -> CCUGinfo )
2432 {
2433 case( CCUG_INFO_No ):
2434 break;
2435 case( CCUG_INFO_SuppOa ):
2436 pfilled_ctb->OAsup = TRUE;
2437 break;
2438 case( CCUG_INFO_SuppPrefCug ):
2439 pfilled_ctb->CUGprf = TRUE;
2440 break;
2441 case( CCUG_INFO_SuppBoth ):
2442 pfilled_ctb->OAsup = TRUE;
2443 pfilled_ctb->CUGprf = TRUE;
2444 break;
2445 }
2446 }
2447
2448 #ifdef SIM_TOOLKIT
2449 /*
2450 *-----------------------------------------------------------------
2451 * SAT settings
2452 *-----------------------------------------------------------------
2453 */
2454
2455 /* decides if a disconnect event for a call has already been sent to SAT */
2456 pfilled_ctb->SatDiscEvent = FALSE;
2457 #endif
2458
2459 /*
2460 *-----------------------------------------------------------------
2461 * bearer services
2462 *-----------------------------------------------------------------
2463 */
2464 switch( callType )
2465 {
2466 /*
2467 *-----------------------------------------------------------------
2468 * start with a voice call
2469 *-----------------------------------------------------------------
2470 */
2471 case( D_TOC_Voice ):
2472
2473 pfilled_ctb->BC[0].rate = MNCC_UR_NOT_PRES;
2474 pfilled_ctb->BC[0].bearer_serv = cmhCC_set_speech_serv (pCCCmdPrm);
2475 pfilled_ctb->BC[0].conn_elem = MNCC_CONN_ELEM_NOT_PRES;
2476
2477 switch( ccShrdPrm.CMODmode )
2478 {
2479
2480 case( CMOD_MOD_Single ): /* single voice call */
2481 pfilled_ctb->rptInd = MNCC_RI_NOT_PRES;
2482
2483 pfilled_ctb->BC[1].rate = MNCC_UR_NOT_PRES;
2484 pfilled_ctb->BC[1].bearer_serv = MNCC_BEARER_SERV_NOT_PRES;
2485 pfilled_ctb->BC[1].conn_elem = MNCC_CONN_ELEM_NOT_PRES;
2486 break;
2487 #if defined (UART) AND defined (FAX_AND_DATA)
2488 case( CMOD_MOD_VoiceDat ): /* alternating voice/data call */
2489 pfilled_ctb->rptInd = MNCC_RI_CIRCULAR;
2490
2491 pfilled_ctb->BC[1].rate = cmhCC_SelRate( ccShrdPrm.CBSTspeed );
2492 pfilled_ctb->BC[1].bearer_serv = cmhCC_SelServ( ccShrdPrm.CBSTname );
2493 pfilled_ctb->BC[1].conn_elem = cmhCC_SelCE ( ccShrdPrm.CBSTce );
2494 pfilled_ctb->BC[1].modem_type = cmhCC_SelMT ( ccShrdPrm.CBSTspeed );
2495
2496 pfilled_ctb->BC[1].stop_bits = cmhCC_SelStopBit( srcId );
2497 pfilled_ctb->BC[1].data_bits = cmhCC_SelDataBit( srcId );
2498 pfilled_ctb->BC[1].parity = cmhCC_SelParity ( srcId );
2499 break;
2500
2501 case( CMOD_MOD_VoiceFlwdDat ): /* voice followed by data */
2502 pfilled_ctb->rptInd = MNCC_RI_CIRCULAR;
2503
2504 pfilled_ctb->BC[1].rate = cmhCC_SelRate( ccShrdPrm.CBSTspeed );
2505 pfilled_ctb->BC[1].bearer_serv = cmhCC_SelServ( ccShrdPrm.CBSTname );
2506 pfilled_ctb->BC[1].conn_elem = cmhCC_SelCE( ccShrdPrm.CBSTce );
2507 pfilled_ctb->BC[1].modem_type = cmhCC_SelMT ( ccShrdPrm.CBSTspeed );
2508
2509 pfilled_ctb->BC[1].stop_bits = cmhCC_SelStopBit( srcId );
2510 pfilled_ctb->BC[1].data_bits = cmhCC_SelDataBit( srcId );
2511 pfilled_ctb->BC[1].parity = cmhCC_SelParity ( srcId );
2512 break;
2513
2514 case( CMOD_MOD_VoiceFax ): /* alternating voice/fax call */
2515 pfilled_ctb->rptInd = MNCC_RI_CIRCULAR;
2516
2517 pfilled_ctb->BC[1].rate = cmhCC_SelRate( ccShrdPrm.CBSTspeed );
2518 pfilled_ctb->BC[1].bearer_serv = MNCC_BEARER_SERV_FAX;
2519 pfilled_ctb->BC[1].conn_elem = MNCC_CONN_ELEM_TRANS;
2520 pfilled_ctb->BC[1].modem_type = MNCC_MT_NONE;
2521 break;
2522 #endif
2523 default: /* unexpected call mode */
2524 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_DataCorrupt );
2525 return( AT_FAIL );
2526 }
2527 break;
2528
2529
2530 /*
2531 *-----------------------------------------------------------------
2532 * start with a data call
2533 *-----------------------------------------------------------------
2534 */
2535 #ifdef FAX_AND_DATA
2536
2537 case( D_TOC_Data ):
2538
2539 switch( ccShrdPrm.CMODmode )
2540 {
2541 case( CMOD_MOD_Single ): /* single data call */
2542 pfilled_ctb->rptInd = MNCC_RI_NOT_PRES;
2543
2544 pfilled_ctb->BC[0].rate = cmhCC_SelRate( ccShrdPrm.CBSTspeed );
2545
2546 #ifdef FF_FAX
2547 if( pT30CmdPrm -> FCLASSclass EQ FCLASS_CLASS_Fax20 )
2548 {
2549 pfilled_ctb->BC[0].bearer_serv = MNCC_BEARER_SERV_FAX;
2550 pfilled_ctb->BC[0].conn_elem = MNCC_CONN_ELEM_TRANS;
2551 pfilled_ctb->BC[0].modem_type = MNCC_MT_NONE;
2552 }
2553 else
2554 #endif /* FF_FAX */
2555 {
2556 pfilled_ctb->BC[0].bearer_serv = cmhCC_SelServ( ccShrdPrm.CBSTname );
2557 pfilled_ctb->BC[0].conn_elem = cmhCC_SelCE( ccShrdPrm.CBSTce );
2558 pfilled_ctb->BC[0].modem_type = cmhCC_SelMT ( ccShrdPrm.CBSTspeed );
2559
2560 pfilled_ctb->BC[0].rate_adaption = cmhCC_SelRateAdaption
2561 (ccShrdPrm.CBSTspeed);
2562
2563 pfilled_ctb->BC[0].transfer_cap = cmhCC_SelTransferCap
2564 (ccShrdPrm.CBSTspeed);
2565
2566 pfilled_ctb->BC[0].stop_bits = cmhCC_SelStopBit( srcId );
2567 pfilled_ctb->BC[0].data_bits = cmhCC_SelDataBit( srcId );
2568 pfilled_ctb->BC[0].parity = cmhCC_SelParity ( srcId );
2569 }
2570
2571 pfilled_ctb->BC[1].rate = MNCC_UR_NOT_PRES;
2572 pfilled_ctb->BC[1].bearer_serv = MNCC_BEARER_SERV_NOT_PRES;
2573 pfilled_ctb->BC[1].conn_elem = MNCC_CONN_ELEM_NOT_PRES;
2574 break;
2575
2576 case( CMOD_MOD_VoiceDat ): /* alternating data/voice call */
2577 pfilled_ctb->rptInd = MNCC_RI_CIRCULAR;
2578
2579 pfilled_ctb->BC[0].rate = cmhCC_SelRate( ccShrdPrm.CBSTspeed );
2580 pfilled_ctb->BC[0].bearer_serv = cmhCC_SelServ( ccShrdPrm.CBSTname );
2581 pfilled_ctb->BC[0].conn_elem = cmhCC_SelCE( ccShrdPrm.CBSTce );
2582 pfilled_ctb->BC[0].modem_type = cmhCC_SelMT ( ccShrdPrm.CBSTspeed );
2583
2584 pfilled_ctb->BC[0].stop_bits = cmhCC_SelStopBit( srcId );
2585 pfilled_ctb->BC[0].data_bits = cmhCC_SelDataBit( srcId );
2586 pfilled_ctb->BC[0].parity = cmhCC_SelParity ( srcId );
2587
2588 pfilled_ctb->BC[1].rate = MNCC_UR_NOT_PRES;
2589 pfilled_ctb->BC[1].bearer_serv = cmhCC_set_speech_serv (pCCCmdPrm);
2590 pfilled_ctb->BC[1].conn_elem = MNCC_CONN_ELEM_NOT_PRES;
2591 break;
2592
2593 case( CMOD_MOD_VoiceFlwdDat ): /* voice followed by data call */
2594
2595 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
2596 return( AT_FAIL ); /* operation not allowed */
2597
2598 case( CMOD_MOD_VoiceFax ): /* alternating fax/voice call */
2599 pfilled_ctb->rptInd = MNCC_RI_CIRCULAR;
2600
2601 pfilled_ctb->BC[0].rate = cmhCC_SelRate( ccShrdPrm.CBSTspeed );
2602 pfilled_ctb->BC[0].bearer_serv = MNCC_BEARER_SERV_FAX;
2603 pfilled_ctb->BC[0].conn_elem = MNCC_CONN_ELEM_TRANS;
2604 pfilled_ctb->BC[0].modem_type = MNCC_MT_NONE;
2605
2606 pfilled_ctb->BC[1].rate = MNCC_UR_NOT_PRES;
2607 pfilled_ctb->BC[1].bearer_serv = cmhCC_set_speech_serv (pCCCmdPrm);
2608 pfilled_ctb->BC[1].conn_elem = MNCC_CONN_ELEM_NOT_PRES;
2609 break;
2610
2611 default: /* unexpected call mode */
2612 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_DataCorrupt );
2613 return( AT_FAIL );
2614 }
2615 break;
2616 #endif /* of #ifdef FAX_AND_DATA */
2617
2618 default: /* unexpected call type */
2619 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_DataCorrupt );
2620 return( AT_FAIL );
2621 }
2622
2623 return( AT_CMPL );
2624 }
2625
2626 #ifdef FF_TTY
2627 /*
2628 +--------------------------------------------------------------------+
2629 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
2630 | STATE : code ROUTINE : cmhCC_notifyTTY |
2631 +--------------------------------------------------------------------+
2632
2633 PURPOSE : This function converts the TTY activity to the trx state
2634 to be provided by '%CTYI: ...'.
2635 */
2636
2637 GLOBAL T_ACI_CTTY_TRX cmhCC_getTTYtrx_state (int ttyTrxState)
2638 {
2639 switch (ttyTrxState)
2640 {
2641 case TTY_OFF:
2642 return CTTY_TRX_Off;
2643 case TTY_HCO:
2644 return CTTY_TRX_SendOn;
2645 case TTY_VCO:
2646 return CTTY_TRX_RcvOn;
2647 case TTY_ALL:
2648 return CTTY_TRX_RcvSendOn;
2649 default:
2650 break;
2651 }
2652 return CTTY_TRX_Unknown;
2653 }
2654
2655 /*
2656 +--------------------------------------------------------------------+
2657 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
2658 | STATE : code ROUTINE : cmhCC_notifyTTY |
2659 +--------------------------------------------------------------------+
2660
2661 PURPOSE : This function generates the unsolicited message '%CTYI: ...'
2662 for any logical channel having registered for.
2663 */
2664
2665 GLOBAL void cmhCC_notifyTTY (T_ACI_CTTY_NEG neg,
2666 T_ACI_CTTY_TRX trx)
2667 {
2668 int i;
2669
2670 for (i = CMD_SRC_LCL; i < CMD_SRC_MAX; i++)
2671 {
2672 if (cmhPrm[i].ccCmdPrm.CTTYmode EQ CTTY_MOD_Enable)
2673 {
2674 R_AT (RAT_CTYI, (T_ACI_CMD_SRC)i) (neg, trx);
2675 }
2676 }
2677 }
2678 #endif /* FF_TTY */
2679
2680 /*
2681 +--------------------------------------------------------------------+
2682 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
2683 | STATE : code ROUTINE : cmhCC_checkALS_Support |
2684 +--------------------------------------------------------------------+
2685
2686 PURPOSE : These function checks for ALS support in two steps
2687 */
2688
2689 GLOBAL void cmhCC_checkALS_Support()
2690 {
2691 TRACE_FUNCTION ("cmhCC_checkALS_Support()");
2692
2693 /* Step #1: read CPHS info first */
2694 cmhSIM_ReadTranspEF( CMD_SRC_NONE,
2695 AT_CMD_NONE,
2696 FALSE,
2697 NULL,
2698 SIM_CPHS_CINF,
2699 0,
2700 ACI_CPHS_INFO_SIZE,
2701 NULL,
2702 cmhCC_checkALS_Support_cb );
2703 }
2704
2705 GLOBAL void cmhCC_checkALS_Support_2()
2706 {
2707 TRACE_FUNCTION ("cmhCC_checkALS_Support_2()");
2708
2709 /* Step #2: then read the actual CSP */
2710 cmhSIM_ReadTranspEF( CMD_SRC_NONE,
2711 AT_CMD_NONE,
2712 FALSE,
2713 NULL,
2714 SIM_CPHS_CSP,
2715 0,
2716 0,
2717 NULL,
2718 cmhCC_checkALS_Support_cb_2 );
2719 }
2720
2721 /*
2722 +--------------------------------------------------------------------+
2723 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
2724 | STATE : code ROUTINE : cmhCC_redialCheck |
2725 +--------------------------------------------------------------------+
2726
2727 PURPOSE : This function evaluates conditions for redialling
2728 */
2729
2730 GLOBAL void cmhCC_redialCheck(SHORT cId)
2731 {
2732 T_CC_CALL_TBL *ctbFail = ccShrdPrm.ctb[ccShrdPrm.cIdFail];
2733 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
2734 SHORT error_indication;
2735 int i;
2736
2737 TRACE_FUNCTION ("cmhCC_redialCheck()");
2738
2739 /* check conditions for error_indication check */
2740 if((rdlPrm.rdlMod EQ AUTOM_REPEAT_ON) AND (rdlPrm.rdlcId EQ NO_ENTRY))
2741 {/* if black list is full no further redial attempts; user has to delete the black list */
2742 #ifdef TI_PS_FF_AT_P_CMD_RDLB
2743 if(cmhCC_redialChkBlackl(cId) EQ AT_CMPL)
2744 {
2745 if(cc_blacklist_ptr->blCount NEQ MAX_NUM_ENTR_BLACK_LIST)
2746 {
2747 #endif /* TI_PS_FF_AT_P_CMD_RDLB */
2748 if( ccShrdPrm.cIdFail < 0 OR ccShrdPrm.cIdFail > MAX_CALL_NR )
2749 {
2750 error_indication = GET_CAUSE_VALUE(CAUSE_MAKE(DEFBY_STD,
2751 ORIGSIDE_MS,
2752 MNCC_ACI_ORIGINATING_ENTITY,
2753 NOT_PRESENT_8BIT));
2754 }
2755 else if( GET_CAUSE_VALUE(ctbFail->rejCs) NEQ NOT_PRESENT_8BIT )
2756 {
2757 error_indication = GET_CAUSE_VALUE(ctbFail->rejCs);
2758 }
2759 else if( GET_CAUSE_VALUE(ctbFail->nrmCs) NEQ NOT_PRESENT_8BIT )
2760 {
2761 error_indication = GET_CAUSE_VALUE(ctbFail->nrmCs);
2762 }
2763 else if( GET_CAUSE_VALUE(ctbFail->rslt) NEQ NOT_PRESENT_8BIT )
2764 {
2765 error_indication = GET_CAUSE_VALUE(ctbFail->rslt);
2766 }
2767 else
2768 {/* in case network has sent no extended report */
2769 error_indication = GET_CAUSE_VALUE(CAUSE_MAKE(DEFBY_STD,
2770 ORIGSIDE_MS,
2771 MNCC_ACI_ORIGINATING_ENTITY,
2772 NOT_PRESENT_8BIT));
2773 }
2774
2775 /* check error_indication (ETSI 2.07, Annex A) and redial counter */
2776 switch (error_indication)
2777 {
2778 /*** indications of category 1 ***/
2779 case 17: /* user busy */
2780 /*** indications of category 2 ***/
2781 case 18: /* no user responding */
2782 case 19: /* user alterting, no answer */
2783 case 27: /* destination out of order */
2784 case 34: /* no circuit/channel available */
2785 case 41: /* temporary failure */
2786 case 42: /* switching equipment congestion */
2787 case 44: /* requested circuit/channel available */
2788 case 47: /*esources unavailable, unspecified */
2789
2790 /* Implements Measure 197, 198 and 199 */
2791 if( (ctb->rdlCnt >= 4) AND (ctb->rdlCnt < MAX_NUM_REPEAT_ATT) )
2792 {
2793 #ifndef _SIMULATION_
2794 ctb->rdlTimIndex = 1;
2795 #endif
2796 }
2797 cmhCC_redialAttempt( cId, ctb->rdlCnt );
2798 /* else : ctb->rdlCnt = MAX_NUM_REPEAT_ATT -> entry is black list */
2799 break;
2800 /*** indications of category 3 -> only one redial attempt is allowed ***/
2801 case 28: /* invalid number format */
2802 ctb->rdlCnt = 0;
2803 break; /* for incorrect number we do not start redialling */
2804 case 1: /* unassigned (unallocated) number */
2805 case 3: /* no route to destination */
2806 case 22: /* number changed */
2807 case 38: /* network out of order */
2808 if(!ctb->rdlCnt)
2809 {/* first redial attempt */
2810 ctb->rdlCnt = MAX_NUM_REPEAT_ATT - 1;
2811 rdlPrm.rdlcId = cId;
2812 /* 5+5 sec for first (= only) call attempt */
2813 TIMERSTART(ACI_REPEAT_1+ACI_DELAY_TIMER,ACI_REPEAT_HND);
2814 for(i = 0; i < CMD_SRC_MAX; i++)
2815 {
2816 R_AT(RAT_RDL, (T_ACI_CMD_SRC)i)(CALL_ATTEMPT_FAILED);
2817 R_AT(RAT_RDL, (T_ACI_CMD_SRC)i)(REDIAL_TIM_START);
2818 }
2819 }
2820 else
2821 {/* more than one attempt is not allowed --> entry in blacklist */
2822 ctb->rdlCnt = MAX_NUM_REPEAT_ATT;
2823 for(i = 0; i < CMD_SRC_MAX; i++)
2824 {
2825 R_AT(RAT_RDL,(T_ACI_CMD_SRC) i)(CALL_ATTEMPT_FAILED);
2826 }
2827 }
2828 break;
2829 default:
2830 ctb->rdlCnt = 0;
2831 break;
2832 }
2833 #ifdef TI_PS_FF_AT_P_CMD_RDLB
2834 }
2835 #endif /* TI_PS_FF_AT_P_CMD_RDLB */
2836 #ifdef TI_PS_FF_AT_P_CMD_RDLB
2837 /* check redial counter against black list: add entry if the list is not full yet */
2838 if(ctb->rdlCnt EQ MAX_NUM_REPEAT_ATT)
2839 {
2840 if (cc_blacklist_ptr->blCount< MAX_NUM_ENTR_BLACK_LIST)
2841 {
2842 /* add entry in black list */
2843 cc_blacklist_ptr->blCount++;
2844 cc_blacklist_ptr->blNum[cc_blacklist_ptr->blCount-1].numb_len =
2845 ctb->cldPty.c_called_num;
2846 memcpy(cc_blacklist_ptr->blNum[cc_blacklist_ptr->blCount-1].number,
2847 ctb->cldPty.called_num,
2848 ctb->cldPty.c_called_num);
2849 cc_blacklist_ptr->blNum[cc_blacklist_ptr->blCount-1].type.ton =
2850 (T_ACI_TOA_TON)ctb->cldPty.ton;
2851 cc_blacklist_ptr->blNum[cc_blacklist_ptr->blCount-1].type.npi =
2852 (T_ACI_TOA_NPI)ctb->cldPty.npi;
2853
2854 ctb->rdlCnt = 0; /* reset redial counter in call table */
2855 ctb->rdlTimIndex = RDL_TIM_INDEX_NOT_PRESENT;
2856 if(cc_blacklist_ptr->blCount EQ MAX_NUM_ENTR_BLACK_LIST)
2857 {
2858 for(i = 0; i < CMD_SRC_MAX; i++)
2859 {
2860 R_AT(RAT_RDLB, (T_ACI_CMD_SRC)i)(BLACKLIST_FULL);
2861 }
2862 }
2863 else
2864 {
2865 for(i = 0; i < CMD_SRC_MAX; i++)
2866 {
2867 R_AT(RAT_RDLB, (T_ACI_CMD_SRC)i)(ENTRY_BLACKLISTED);
2868 }
2869 }
2870 }
2871 }
2872 else
2873 {
2874 return;
2875 }
2876 } /* End of if (cc_blacklist_ptr->blCount< MAX_NUM_ENTR_BLACK_LIST) */
2877 #ifdef SIM_TOOLKIT
2878 cmhSAT_NtwErr( (UBYTE)((GET_CAUSE_VALUE(ccShrdPrm.ctb[cId]->nrmCs) NEQ NOT_PRESENT_8BIT)?
2879 (ccShrdPrm.ctb[cId]->nrmCs|0x80) : ADD_NO_CAUSE));
2880 /*
2881 * If cId is blacklisted, We need to stop the SAT Max duration timer
2882 * and reset the SAT max duration
2883 */
2884 if(satShrdPrm.dur)
2885 {
2886 TIMERSTOP(ACI_SAT_MAX_DUR_HND);
2887 satShrdPrm.dur = -1;
2888 }
2889 #endif /* SIM_TOOKIT */
2890 #endif /* TI_PS_FF_AT_P_CMD_RDLB */
2891 }
2892 }
2893
2894 #ifdef TI_PS_FF_AT_P_CMD_RDLB
2895 /*
2896 +--------------------------------------------------------------------+
2897 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
2898 | STATE : code ROUTINE : cmhCC_redialChkBlackl |
2899 +--------------------------------------------------------------------+
2900
2901 PURPOSE : This function checks the new cId against the black list
2902 */
2903
2904 GLOBAL T_ACI_RETURN cmhCC_redialChkBlackl(SHORT cId)
2905 {
2906 UBYTE bl_index = 0;
2907 int i;
2908
2909 TRACE_FUNCTION ("cmhCC_redialChkBlackl()");
2910
2911 if(cc_blacklist_ptr NEQ NULL)
2912 {
2913 for(bl_index=0; bl_index<cc_blacklist_ptr->blCount;bl_index++)
2914 {
2915 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
2916
2917 if (memcmp (cc_blacklist_ptr->blNum[bl_index].number,
2918 ctb->cldPty.called_num,
2919 ctb->cldPty.c_called_num) EQ 0)
2920 {
2921 for(i = 0; i < CMD_SRC_MAX; i++)
2922 {
2923 R_AT(RAT_RDLB, (T_ACI_CMD_SRC)i)(ENTRY_IN_BLACKLIST);
2924 }
2925 return( AT_FAIL );
2926 }
2927 }
2928 }
2929 return( AT_CMPL );
2930 }
2931 #endif /* TI_PS_FF_AT_P_CMD_RDLB */
2932 #if defined(_TARGET_)
2933 /*
2934 +--------------------------------------------------------------------+
2935 | PROJECT : GSM-PS (6147) MODULE : CMH_CCF |
2936 | STATE : code ROUTINE : cmhCC_rd_mode_FFS |
2937 +--------------------------------------------------------------------+
2938
2939 PURPOSE : This function writes redial_mode in FFS
2940 */
2941
2942 GLOBAL T_ACI_RETURN cmhCC_rd_mode_FFS(T_ACI_CC_REDIAL_MODE rdl_mode,
2943 T_ACI_CC_RDL_FFS ffs_mode)
2944 {
2945 T_ACI_CC_REDIAL_MODE redial_mode;
2946
2947 TRACE_FUNCTION ("cmhCC_rd_mode_FFS()");
2948
2949 /* Implements Measure#32: Row 73 */
2950 switch(FFS_mkdir(gsm_com_path))
2951 {/* create/check ffs directory */
2952 case EFFS_OK:
2953 case EFFS_EXISTS:
2954 break;
2955 default:
2956 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
2957 return ( AT_FAIL );
2958 }
2959
2960 if(ffs_mode EQ WRITE_RDLmode)
2961 {
2962 /* Implements Measure#32: Row 74 */
2963 if(FFS_fwrite(gsm_com_redialmode_path,&rdl_mode, sizeof(T_ACI_CC_REDIAL_MODE)) NEQ EFFS_OK)
2964 {
2965 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
2966 return ( AT_FAIL );
2967 }
2968 return AT_CMPL;
2969 }
2970 else if(ffs_mode EQ READ_RDLmode)
2971 {
2972 /* Implements Measure#32: Row 74 */
2973 FFS_fread(gsm_com_redialmode_path,&redial_mode, sizeof(T_ACI_CC_REDIAL_MODE));
2974 switch(redial_mode)
2975 {
2976 case AUTOM_REP_NOT_PRESENT:
2977 rdlPrm.rdlMod = AUTOM_REPEAT_OFF;
2978 return AT_CMPL;
2979 case AUTOM_REPEAT_OFF:
2980 case AUTOM_REPEAT_ON:
2981 rdlPrm.rdlMod = redial_mode;
2982 return AT_CMPL;
2983 default:
2984 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
2985 return ( AT_FAIL );
2986 }
2987 }
2988 else
2989 {
2990 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
2991 return ( AT_FAIL );
2992 }
2993 }
2994 #endif /* _TARGET_ */
2995
2996 /* Implements Measure 197, 198 and 199 */
2997 /*
2998 +------------------------------------------------------------------------------
2999 | Function : cmhCC_redialAttempt
3000 +------------------------------------------------------------------------------
3001 | Purpose : This Function will Attempt for Redialling.
3002 |
3003 | Parameters : srcId - AT command source identifier.
3004 | rdlCnt - Redial Counter
3005 |
3006 | Return : void
3007 +------------------------------------------------------------------------------
3008 */
3009
3010 LOCAL void cmhCC_redialAttempt( SHORT cId, UBYTE rdlCnt )
3011 {
3012 int i;
3013
3014 TRACE_FUNCTION ("cmhCC_redialAttempt()");
3015
3016 if(!rdlCnt)
3017 {
3018 rdlPrm.rdlcId = cId;
3019 #ifdef SIM_TOOLKIT
3020 if (satShrdPrm.dur NEQ -1)
3021 {
3022 /* Start the SAT max duration timer before the first redial attempt*/
3023 TIMERSTART(satShrdPrm.dur,ACI_SAT_MAX_DUR_HND);
3024 }
3025 #endif /* SIM_TOOLKIT */
3026
3027 /* first redial attempt */
3028 TIMERSTART( ACI_REPEAT_1 + ACI_DELAY_TIMER, ACI_REPEAT_HND );
3029 }
3030 else if ( rdlCnt < MAX_NUM_REPEAT_ATT )
3031 {
3032 rdlPrm.rdlcId = cId;
3033 /* from 2nd to 4th redial attempt and from 5th to 10th redial attempt */
3034 #ifdef _SIMULATION_
3035 TIMERSTART( ACI_REPEAT_1, ACI_REPEAT_HND );
3036 #else
3037 TIMERSTART( ACI_REPEAT_2_4 + ACI_DELAY_TIMER, ACI_REPEAT_HND );
3038 #endif
3039 }
3040 else
3041 {
3042 return;
3043 }
3044
3045 for(i = 0; i < CMD_SRC_MAX; i++)
3046 {
3047 R_AT(RAT_RDL, (T_ACI_CMD_SRC)i)(CALL_ATTEMPT_FAILED);
3048 R_AT(RAT_RDL, (T_ACI_CMD_SRC)i)(REDIAL_TIM_START);
3049 }
3050 }
3051
3052
3053
3054 /*==== EOF ========================================================*/
3055