FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/cmh_ccr.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_CCR
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 which are responsible
18 | for the responses of the protocol stack adapter for
19 | call control.
20 +-----------------------------------------------------------------------------
21 */
22
23 #ifndef CMH_CCR_C
24 #define CMH_CCR_C
25 #endif
26
27 #include "config.h"
28 #include "fixedconf.h"
29 #include "condat-features.h"
30 #include "aci_conf.h"
31
32 /*==== INCLUDES ===================================================*/
33
34 #include "aci_all.h"
35 #include "aci_cmh.h"
36 #include "ati_cmd.h"
37 #include "aci_cmd.h"
38 #include "aci_mem.h"
39 #include "phb.h"
40 #include "l4_tim.h"
41 #include "aci_lst.h"
42
43
44 #ifdef FAX_AND_DATA
45 #include "aci_fd.h"
46 #endif /* of #ifdef FAX_AND_DATA */
47
48 #include "aci.h"
49 #include "psa.h"
50 #include "ksd.h"
51 #include "psa_cc.h"
52 #include "psa_ss.h"
53 #include "psa_util.h"
54 #include "cmh.h"
55 #include "cmh_cc.h"
56 #include "cmh_ss.h"
57
58 #ifdef FF_ATI
59 #include "aci_io.h"
60 #endif /* of #ifdef FF_ATI */
61
62 #ifdef UART
63 #include "dti.h" /* functionality of the dti library */
64 #include "dti_conn_mng.h"
65 #include "dti_cntrl_mng.h"
66 #endif
67
68 #ifdef FAX_AND_DATA
69
70 #include "psa_ra.h"
71 #include "cmh_ra.h"
72 #include "psa_l2r.h"
73 #include "cmh_l2r.h"
74 #include "psa_tra.h"
75
76 #ifdef FF_FAX
77 #include "psa_t30.h"
78 #include "cmh_t30.h"
79 #endif /* FF_FAX */
80
81 #endif /* FAX_AND_DATA */
82
83 #ifdef SIM_TOOLKIT
84 #include "psa_sat.h"
85 #include "cmh_sat.h"
86 #include "psa_sim.h"
87 #endif /* of #ifdef SIM_TOOLKIT */
88
89 #include "aoc.h"
90 #include "audio.h"
91
92 #if defined (FF_WAP) || defined (FF_PPP) || defined (FF_GPF_TCPIP) || defined (FF_SAT_E)
93 #include "wap_aci.h"
94 #include "psa_ppp_w.h"
95 #include "cmh_ppp.h"
96 #endif /* of FF_WAP or FF_PPP || FF_GPF_TCPIP FF_SAT_E */
97
98 #if defined (CO_UDP_IP) || defined (FF_GPF_TCPIP)
99 #include "psa_tcpip.h"
100 #include "cmh_ipa.h"
101 #endif /* CO_UDP_IP || FF_GPF_TCPIP */
102
103 #ifdef FF_GPF_TCPIP
104 #include "dcm_utils.h"
105 #include "dcm_state.h"
106 #include "dcm_env.h"
107 #endif
108 #include "dcm_f.h"
109 #ifdef UART
110 #include "psa_uart.h"
111 #include "cmh_uart.h"
112 #endif /*UART*/
113
114 #ifdef FF_PSI
115 #include "psa_psi.h"
116 #include "cmh_psi.h"
117 #endif /*FF_PSI*/
118
119 #include "cmh_phb.h"
120
121 #include "psa_sim.h"
122 #include "cmh_sim.h"
123
124 /*==== CONSTANTS ==================================================*/
125
126 /*==== TYPES ======================================================*/
127
128 /* Implements Measure 90,91 */
129
130 /*
131 * Conversion Array that convert CSSX codes to CSSI codes.
132 * CSSX_CODE is being used as the index of the array and
133 * CSSI_CODE is being used as the contents of the array.
134 */
135
136 const T_ACI_CSSI_CODE cssx2I_Code_Convert[]=
137 {
138 CSSI_CODE_ForwardedCall,
139 CSSI_CODE_CUGCall,
140 CSSI_CODE_NotPresent,
141 CSSI_CODE_NotPresent,
142 CSSI_CODE_NotPresent,
143 CSSI_CODE_NotPresent,
144 CSSI_CODE_NotPresent,
145 CSSI_CODE_NotPresent,
146 CSSI_CODE_NotPresent,
147 CSSI_CODE_CFUActive,
148 CSSI_CODE_SomeCCFActive,
149 CSSI_CODE_CallWaiting,
150 CSSI_CODE_OutCallsBarred,
151 CSSI_CODE_IncCallsBarred,
152 CSSI_CODE_CLIRSupRej,
153 CSSI_CODE_DeflectedCall
154 };
155
156 /*==== EXPORT =====================================================*/
157
158 /*==== VARIABLES ==================================================*/
159
160 #if defined (FF_WAP) || defined (FF_PPP) || defined (FF_GPF_TCPIP) || defined (FF_SAT_E)
161 ULONG ipAddress;
162
163 GLOBAL SHORT cmhCC_PPP_Established (ULONG ip_address,USHORT max_receive_unit,
164 ULONG dns1, ULONG dns2);
165 GLOBAL SHORT cmhCC_PPP_Terminated (void);
166 #endif
167
168 #ifdef CO_UDP_IP
169 GLOBAL SHORT cmhCC_IPA_Configurated (void);
170 GLOBAL SHORT cmhCC_UDPA_Configurated (void);
171 GLOBAL SHORT cmhCC_UDPA_Deconfigurated (void);
172 #endif /* CO_UDP_IP */
173
174 LOCAL void cmhCC_tstAndUnflag_MPTYCall( SHORT cId,
175 UBYTE srcBuf,
176 UBYTE cmdBuf,
177 T_CC_CMD_PRM *pCCCmdPrm );
178 LOCAL BOOL cmhCC_check_isCallServiced( SHORT cId );
179 LOCAL void cmhCC_Call_Progress_Information( SHORT cId, T_ACI_CPI_MSG msgType, USHORT cause );
180
181 /*==== FUNCTIONS ==================================================*/
182
183 /*
184 +-------------------------------------------------------------------+
185 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
186 | ROUTINE : cmhCC_CallAlerted |
187 +-------------------------------------------------------------------+
188
189 PURPOSE : called party is alerted
190
191 */
192
193 GLOBAL void cmhCC_CallAlerted ( SHORT cId )
194 {
195 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
196
197 TRACE_FUNCTION ("cmhCC_CallAlerted()");
198
199 /*
200 *-------------------------------------------------------------------
201 * process event
202 *-------------------------------------------------------------------
203 */
204 if (ctb->prgDesc EQ MNCC_PROG_NOT_PRES)
205 {
206 /* Implements Measure 207 */
207 cmhCC_Call_Progress_Information( cId, CPI_MSG_Alert, ctb->curCs );
208 }
209 return;
210 }
211
212 /*
213 +-------------------------------------------------------------------+
214 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
215 | ROUTINE : cmhCC_CallProceeding |
216 +-------------------------------------------------------------------+
217
218 PURPOSE : call proceed indication
219
220 */
221
222 GLOBAL void cmhCC_CallProceeding ( SHORT cId )
223 {
224 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
225 T_ACI_CPI_MSG msgType;
226
227 TRACE_FUNCTION ("cmhCC_CallProceeding()");
228
229 /*
230 *-------------------------------------------------------------------
231 * process event
232 *-------------------------------------------------------------------
233 */
234 switch( ccShrdPrm.msgType )
235 {
236 case( MT_SETUP ): msgType = CPI_MSG_Setup; break;
237 case( MT_DISC ):
238 switch (ctb->calStat)
239 {
240 case NO_VLD_CS:
241 case CS_ACT_REQ:
242 case CS_CPL_REQ:
243 case CS_DSC_REQ:
244 break;
245 default:
246 return;
247 }
248 msgType = CPI_MSG_Disc;
249 break;
250 case( MT_ALRT ): msgType = CPI_MSG_Alert; break;
251 case( MT_PROC ): msgType = CPI_MSG_Proc; break;
252 case( MT_PROGR ): msgType = CPI_MSG_Progr; break;
253 /* case( MT_CONN ): msgType = CPI_MSG_Conn; break; */
254 case( MT_CONN ): return; /* CPI is generated in cmhCC_CallConnected */
255 default: TRACE_EVENT("UNEXP MSG TYPE IN CC SHRD PARM");
256 return;
257 }
258
259 /* ctb->curCs = MNCC_CAUSE_NO_MS_CAUSE; */
260 /* Implements Measure 207 */
261 cmhCC_Call_Progress_Information( cId, msgType, ctb->curCs );
262
263 return;
264 }
265
266 /*
267 +-------------------------------------------------------------------+
268 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
269 | ROUTINE : cmhCC_CallConnected |
270 +-------------------------------------------------------------------+
271
272 PURPOSE : call is connected
273
274 */
275
276 GLOBAL void cmhCC_CallConnected ( SHORT cId )
277 {
278 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
279 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
280 CHAR numBuf[MNCC_MAX_CC_CALLING_NUMBER+1]; /* buffers calling number + '\0' */
281 CHAR subBuf[MNCC_SUB_LENGTH+1]; /* buffers subaddress 'subaddress\0' */
282 T_ACI_TOA toaBuf; /* buffers type of address */
283 T_ACI_TOS tosBuf; /* buffers type of subaddress */
284 UBYTE cmdBuf; /* buffers current command */
285 UBYTE srcBuf; /* buffers current command source */
286 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
287
288 TRACE_FUNCTION ("cmhCC_CallConnected()");
289
290 /* check for command context */
291 switch(ctb->curCmd)
292 {
293 case(AT_CMD_D):
294 case(AT_CMD_A):
295 case(AT_CMD_CHLD):
296 break;
297
298 default:
299 TRACE_EVENT_P1("cmhCC_CallConnected(): wrong command context %d", ctb->curCmd);
300 return;
301 }
302
303 /* call progress information */
304 /* Implements Measure 207 */
305 cmhCC_Call_Progress_Information( cId, CPI_MSG_Conn, ctb->curCs );
306
307 /* process event for D, A and +CHLD command */
308 pCCCmdPrm = &cmhPrm[ctb->curSrc].ccCmdPrm;
309
310 if (ctb->curCmd EQ AT_CMD_D)
311 {
312 /* Check if user allows Connected Line Presentation: FTA 31.1.3.1 */
313 switch (ctb->clgPty.present)
314 {
315 case (MNCC_PRES_PRES_ALLOW): /* presentation allowed FTA 31.1.3.1 */
316 TRACE_EVENT ("cmhCC_CallConnected(): presentation allowed !");
317 break;
318
319 case (MNCC_PRES_NOT_PRES):
320 TRACE_EVENT ("cmhCC_CallConnected(): presentation not present !");
321 break;
322
323 case (MNCC_PRES_PRES_REST): /* presentation restricted FTA 31.1.4.2 procedure 1 */
324 TRACE_EVENT ("cmhCC_CallConnected(): presentation restricted !");
325 /*
326 * R_AT( RAT_COLR, ccShrdPrm.???.???.??? )
327 * ( COLR_STAT_??? );
328 */
329 break;
330
331 case (MNCC_PRES_NUMB_NOT_AVAIL): /* number not available due to interworking FTA 31.1.4.2 procedure 2 */
332 TRACE_EVENT ("cmhCC_CallConnected(): number not available due to interworking !");
333 /*
334 * R_AT( RAT_COLR, ccShrdPrm.???.???.??? )
335 * ( COLR_STAT_??? );
336 */
337 break;
338
339 default:
340 TRACE_EVENT ("[ERR] cmhCC_CallConnected(): pCtbNtry->clgPty.present = UNKNOWN");
341 return;
342
343 }
344
345 if ((ctb->clgPty.present NEQ MNCC_PRES_NOT_PRES) /* any .present indicator received from MSC? */
346 AND (ctb->clgPty.c_num EQ 0) ) /* but no number available? */
347 {
348 ; /* do nothig */
349 }
350 else
351 {
352 /*
353 * This function call (rAT_PlusCOLP) informs MWF/BMI about
354 * presentation of the called number on display.
355 * If MFW did not receive this function call, then it should
356 * not display the number after querying the call state with
357 * qAT_PercentCAL() where it gets the typed in called number, unfortunately
358 */
359 R_AT( RAT_COLP, (T_ACI_CMD_SRC)ctb->curSrc )
360 ( COLP_STAT_NotPresent,
361 psaCC_ctbClrAdr2Num( cId, numBuf, sizeof (numBuf) ),
362 cmhCC_ctbGetClrNumTyp( cId, &toaBuf ),
363 psaCC_ctbClrAdr2Sub( cId, subBuf ),
364 cmhCC_ctbGetClrSubTyp( cId, &tosBuf ),
365 psaCC_ctbGetAlpha( cId) );
366 }
367 }
368
369
370 /* reset CMOD to single mode */
371 ccShrdPrm.CMODmode = CMOD_MOD_Single;
372
373 switch(calltype)
374 {
375 /* Speech Call */
376 case( VOICE_CALL ):
377 cmdBuf = ctb->curCmd;
378 srcBuf = ctb->curSrc;
379
380 /* reset CMOD to single mode */
381 if( ctb->BC[1].bearer_serv NEQ MNCC_BEARER_SERV_NOT_PRES )
382 {
383 ccShrdPrm.CMODmode = CMOD_MOD_Single;
384 }
385
386 /*
387 * check if connect is expected
388 */
389 if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyCncFlg)))
390 {
391 if( pCCCmdPrm -> mltyCncFlg EQ 0 ) /* if last call */
392 {
393
394 #ifdef SIM_TOOLKIT
395 if( ctb->SATinv )
396 {
397 cmhSAT_CallCncted();
398 ctb->SATinv = FALSE; /* unsent */
399 }
400 #endif /* SIM_TOOLKIT */
401 if(!cmhCC_atdsendok(cId)) /* if OK hasn't been sent right after MNCC_SETUP_REQ, then send it now */
402 {
403 /* needed for RAT_OK in MFW... Temp until tasks are separated */
404 cmhCC_PrepareCmdEnd (cId, NULL, NULL);
405
406 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf );
407 }
408
409 /* log result */
410 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_OK,(T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1),
411 BS_SPEED_NotPresent, CME_ERR_NotPresent );
412 }
413 }
414 cmhCC_PrepareCmdEnd (cId, NULL, NULL);
415 break;
416
417 #if defined (FAX_AND_DATA) AND defined (DTI)
418
419 /* in case of a supported data call */
420 case(TRANS_CALL):
421 case(NON_TRANS_CALL):
422 case(FAX_CALL):
423 #ifdef FF_PPP
424 /* PPP call initialisation (AAA - PPP - L2R) */
425 case(PPP_CALL):
426 #endif /* FF_PPP */
427 /* wait for TCH if not assigned */
428 if( ccShrdPrm.TCHasg )
429 {
430 /* activate RA connection: in case of failure clear call ! */
431 ccShrdPrm.datStat = DS_ACT_REQ;
432
433 if (cmhRA_Activate( (T_ACI_CMD_SRC)ctb->curSrc, (T_ACI_AT_CMD)ctb->curCmd, cId ) NEQ AT_EXCT)
434 {
435 TRACE_EVENT("RA ACTIVATION FAILURE -> DISC CALL");
436 ccShrdPrm.datStat = DS_IDL;
437 ctb->nrmCs = MNCC_CAUSE_CALL_CLEAR;
438 psaCC_ClearCall (cId);
439 #if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
440 /* check impact for SAT commands */
441 cmhSAT_OpChnCSDDown( cId, TPL_NONE );
442 #endif /* SIM TOOLKIT AND FF_SAT_E */
443 }
444 }
445 break;
446
447 #if defined(CO_UDP_IP) OR defined(FF_GPF_TCPIP)
448 #ifdef CO_UDP_IP
449 case(UDPIP_CALL):
450 #endif
451 #ifdef FF_GPF_TCPIP
452 case(TCPIP_CALL):
453 #endif
454 /* wait for TCH if not assigned */
455 if( ccShrdPrm.TCHasg )
456 {
457 if (wap_state NEQ Wap_Not_Init) /* release call */
458 {
459 TRACE_EVENT("FATAL ERROR in cmhCC_CallConnected: WAP Call already in process");
460 ctb->nrmCs = MNCC_CAUSE_CALL_CLEAR;
461 psaCC_ClearCall (cId);
462 #if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
463 cmhSAT_OpChnCSDDown( cId, UDP );
464 #endif /* SIM TOOLKIT AND FF_SAT_E */
465 break;
466 }
467 else
468 {
469 TRACE_EVENT("WAP call initialisation");
470 #if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
471 if( cmhSAT_OpChnChckCSD(UDP) )
472 {
473 psaTCPIP_Activate(ctb->curSrc, 0,
474 cId,
475 TCPIP_ACT_OPTION_V4 | TCPIP_ACT_OPTION_UDP,
476 TCPIP_CONNECTION_TYPE_CSD_WAP,
477 cmhSAT_OpChnUDPActiveCsd) ;
478 }
479 else
480 #endif /* SIM TOOLKIT AND FF_SAT_E */
481 {
482 if(is_gpf_tcpip_call())
483 {
484 psaTCPIP_Activate(ctb->curSrc, 0 /* Change this! */,
485 cId,
486 TCPIP_ACT_OPTION_V4 | TCPIP_ACT_OPTION_TCPIP,
487 TCPIP_CONNECTION_TYPE_CSD_WAP,
488 psaTCPIP_act_csd_callback) ;
489 }
490 else
491 {
492 psaTCPIP_Activate(ctb->curSrc, 0 /* Change this! */,
493 cId,
494 TCPIP_ACT_OPTION_V4 | TCPIP_ACT_OPTION_UDP,
495 TCPIP_CONNECTION_TYPE_CSD_WAP,
496 psaTCPIP_act_csd_callback) ;
497 }
498 }
499 }
500 }
501 break;
502 #endif /* defined(WAP) OR defined(FF_GPF_TCPIP) */
503
504 /* in case of an unsupported data call */
505 case(UNSUP_DATA_CALL):
506 TRACE_EVENT("UNSUPPORTED DATA CALL -> DISC CALL");
507 ctb->nrmCs = MNCC_CAUSE_CALL_CLEAR;
508 psaCC_ClearCall (cId);
509 #if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
510 /* check impact for SAT commands */
511 cmhSAT_OpChnCSDDown( cId, TPL_NONE );
512 #endif /* SIM TOOLKIT AND SAT_SAT_E */
513 break;
514
515 #endif /* of #ifdef FAX_AND_DATA */
516
517 default:
518 TRACE_ERROR("Wrong call type");
519 }
520 }
521
522 /*
523 +-------------------------------------------------------------------+
524 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
525 | ROUTINE : process_CHLDaddInfo |
526 +-------------------------------------------------------------------+
527
528 PURPOSE : Local function: processes parameter CHLDaddInfo (continue action that
529 had to wait for a call to be connected first).
530 */
531 /* Held call is being disconnected */
532 #define DISCONNECT_HELD (0)
533 /* Call is being put on hold */
534 #define CALL_HELD (1)
535 /* Multyparty call is being put on hold */
536 #define MTPTY_HELD (2)
537
538 LOCAL void process_CHLDaddInfo( UBYTE srcId, UBYTE context )
539 {
540 /* param context allows to differentiate some special case */
541 SHORT addId;
542 T_CC_CMD_PRM *pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm;
543
544 TRACE_FUNCTION("process_CHLDaddInfo( )");
545
546 for( addId = 0; !((pCCCmdPrm -> mltyCncFlg >> addId) & 0x01); addId++ )
547 ;
548
549 switch( CHLDaddInfo )
550 {
551 case( CHLD_ADD_INFO_ACC_CAL ):
552 cmhCC_AcceptCall(addId, (T_ACI_CMD_SRC)srcId, AT_CMD_CHLD);
553 return;
554
555 case (CHLD_ADD_INFO_DIAL_CAL):
556 cmhCC_NewCall(addId, (T_ACI_CMD_SRC)srcId, AT_CMD_D);
557 return;
558
559 case( CHLD_ADD_INFO_RTV_CAL ):
560 if(context NEQ CALL_HELD)
561 {
562 cmhCC_RetrieveCall(addId, (T_ACI_CMD_SRC)srcId);
563 return;
564 }
565 break;
566
567 case (NO_CHLD_ADD_INFO):
568 if(context EQ DISCONNECT_HELD)
569 {
570 return; /* May happen for CCBS recall, disconnecting the active call */
571 }
572 break;
573 }
574
575 TRACE_EVENT("UNEXP ADD CHLD INFO");
576 }
577
578 /*
579 +-------------------------------------------------------------------+
580 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
581 | ROUTINE : cmhCC_CallDisconnected |
582 +-------------------------------------------------------------------+
583
584 PURPOSE : call is disconnected: process event for D and A command, abort command or no command
585 */
586
587 #ifdef SIM_TOOLKIT
588 LOCAL void cmhCC_CallDisc_whiledialling_sat(SHORT cId, BOOL *send_atresult)
589 {
590 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
591 UBYTE network_cause;
592
593 if( !ctb->SATinv )
594 {
595 return;
596 }
597
598 TRACE_FUNCTION("cmhCC_CallDisc_whiledialling_sat");
599
600 switch(ctb->curCmd)
601 {
602 case( AT_CMD_A ):
603 /* if connect is expected */
604 if( cmhPrm[ctb->curSrc].ccCmdPrm.mltyCncFlg NEQ 0 )
605 {
606 if( ctb->SATinv & SAT_REDIAL )
607 {
608 ctb->calStat = CS_SAT_REQ;
609 return;
610 }
611
612 /* return network error cause GSM 11.14 / 12.12.3 */
613 if(GET_CAUSE_VALUE(ctb->nrmCs) EQ NOT_PRESENT_8BIT)
614 {
615 network_cause = ADD_NO_CAUSE;
616 }
617 else
618 network_cause = GET_CAUSE_VALUE(ctb->nrmCs)|0x80;
619
620 *send_atresult = cmhSAT_NtwErr(network_cause);
621 }
622 break;
623
624 case( AT_CMD_ABRT ):
625 /* if disconnect is expected */
626 if( cmhPrm[ctb->curSrc].ccCmdPrm.mltyDscFlg NEQ 0 )
627 {
628 cmhSAT_UserClear();
629 }
630 break;
631 #ifdef FF_SAT_E
632 default:
633 cmhSAT_OpChnCSDDown( cId, TPL_DONT_CARE );
634 break;
635 #endif /* FF_SAT_E */
636 }
637 }
638 #endif /*#ifdef SIM_TOOLKIT*/
639 /*
640 +------------------------------------------------------------------------------
641 | Function : cmhCC_CallDisc_connectingphase
642 +------------------------------------------------------------------------------
643 | Description : This function checks on call type and disconnects the
644 | different calltypes.
645 |
646 | Parameters : call id
647 |
648 | Return :
649 |
650 +------------------------------------------------------------------------------
651 */
652
653 LOCAL void cmhCC_CallDisc_connectingphase ( SHORT cId )
654 {
655 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
656 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
657 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
658 BOOL atRslt = TRUE; /* flags to send a AT result code */
659
660 TRACE_FUNCTION("cmhCC_CallDisc_connectingphase");
661
662 pCCCmdPrm = &cmhPrm[ctb->curSrc].ccCmdPrm;
663
664 /* reset CMOD to single mode */
665 ccShrdPrm.CMODmode = CMOD_MOD_Single;
666
667 #ifdef SIM_TOOLKIT
668 /* handling of SAT invoked call */
669 cmhCC_CallDisc_whiledialling_sat(cId, &atRslt);
670 #endif /* SIM_TOOLKIT */
671
672 /* Unflag Multiconnect/disconnect Flags */
673 if( ctb->curSrc NEQ CMD_SRC_NONE )
674 {
675 cmhCC_tstAndUnflagCall( cId,
676 &pCCCmdPrm->mltyCncFlg );
677 cmhCC_tstAndUnflagCall( cId,
678 &pCCCmdPrm->mltyDscFlg );
679 }
680
681 /* CCBS handling */
682 if( ctb->curCmd EQ AT_CMD_D AND
683 ctb->CCBSstat EQ CCBSS_PSSBL )
684 {
685 cmhrat_ccbs( CMD_SRC_MAX, CCBS_IND_Possible,
686 CCBS_STAT_NotPresent, NULL );
687 }
688
689 switch( calltype )
690 {
691 case( VOICE_CALL ): /* voice call */
692 /* CSSU indications handling */
693 if( ctb->calStat EQ CS_HLD )
694 {
695 if( ctb->curCmd NEQ AT_CMD_NONE )
696 {
697 send_CSSX_notification(cId,
698 CSSX_CODE_HeldCallRel,
699 ACI_NumParmNotPresent,
700 NULL, NULL, NULL, NULL);
701 }
702 }
703 /* Check for CHLDmode and if all calls are disconnected send
704 OK to the terminal and reset CHLDmode */
705 if (pCCCmdPrm->CHLDmode EQ CHLD_MOD_Ect AND
706 (pCCCmdPrm->mltyCncFlg EQ 0) AND
707 (pCCCmdPrm->mltyDscFlg EQ 0))
708 {
709 pCCCmdPrm->CHLDmode = CHLD_MOD_NotPresent;
710 R_AT( RAT_OK, (T_ACI_CMD_SRC)ctb->curSrc ) ( AT_CMD_CHLD );
711
712 /* log result */
713 cmh_logRslt ( (T_ACI_CMD_SRC)ctb->curSrc, RAT_OK,
714 AT_CMD_CHLD, (SHORT)(cId+1),BS_SPEED_NotPresent, CME_ERR_NotPresent );
715 }
716 break;
717
718 #if defined (FAX_AND_DATA) AND defined (DTI)
719 case(TRANS_CALL):
720 if( ccShrdPrm.datStat NEQ DS_IDL )
721 {
722 ccShrdPrm.datStat = DS_STOP_REQ;
723 cmhTRA_Deactivate ();
724 return;
725 }
726 break;
727
728 case(NON_TRANS_CALL):
729 if( ccShrdPrm.datStat NEQ DS_IDL )
730 {
731 ccShrdPrm.datStat = DS_STOP_REQ;
732 cmhL2R_Deactivate ();
733 return;
734 }
735 break;
736
737 #ifdef FF_FAX
738 case( FAX_CALL ):
739 if( ccShrdPrm.datStat NEQ DS_IDL )
740 {
741 ccShrdPrm.datStat = DS_STOP_REQ;
742 cmhT30_Deactivate ();
743 return;
744 }
745 break;
746 #endif /* FF_FAX */
747
748 #ifdef CO_UDP_IP
749 case(UDPIP_CALL):
750 /* check if a UDP/IP call is in process... If yes then end call */
751 if (ccShrdPrm.datStat NEQ DS_IDL)
752 {
753 ccShrdPrm.datStat = DS_STOP_REQ;
754
755 /* Check command context to know if lower layers of PPP already are down or not */
756 if(ctb->curCmd EQ AT_CMD_NONE OR
757 ctb->curCmd EQ AT_CMD_D )
758 {
759 /* If PPP connected - send terminate request to PPP */
760 if(pppShrdPrm.state EQ PPP_ESTABLISHED)
761 {
762 cmhPPP_Terminate(DWN);
763 }
764 return;
765 }
766 }
767 break;
768 #endif /* CO_UDP_IP */
769
770 #endif /* of #ifdef FAX_AND_DATA */
771 }
772
773 /* Command is done: send response to user if not suppressed */
774 /* if(atRslt) cmhCC_SndDiscRsn( cId ); */ /* to pass 26.8.1.2.8.1 */
775 }
776
777 LOCAL void call_disconnected_data_call(T_CC_CALL_TYPE calltype, SHORT cId)
778 {
779 TRACE_FUNCTION("call_disconnected_data_call");
780
781 /* Local disconnection for PPP if peer shuts down the line
782 instead of normal PPP shutdown */
783 switch( calltype )
784 {
785 #if defined (FAX_AND_DATA) AND defined (DTI)
786 /* check if a WAP call is in process... If yes then end call */
787 #if defined(CO_UDP_IP) || defined(FF_PPP)
788
789 #ifdef CO_UDP_IP
790 case(UDPIP_CALL):
791 #endif /* CO_UDP_IP */
792
793 #if defined(FF_GPF_TCPIP)
794 case (TCPIP_CALL):
795 #endif /* FF_GPF_TCPIP */
796 #ifdef FF_PPP
797 case PPP_CALL:
798 pppShrdPrm.is_PPP_CALL = FALSE;
799 TRACE_EVENT ("is_PPP_CALL resetted");
800 #endif /* FF_PPP */
801 if (ccShrdPrm.datStat NEQ DS_IDL)
802 {
803 ccShrdPrm.datStat = DS_STOP_REQ;
804
805 /* Only local disconnection is possible in this case, the call is already disconnected !
806 if(pppShrdPrm.state EQ PPP_ESTABLISHED)
807 cmhPPP_Terminate(UP); */
808
809 if((pppShrdPrm.state EQ PPP_ESTABLISHED) OR
810 (pppShrdPrm.state EQ PPP_ESTABLISH) OR
811 (pppShrdPrm.state EQ PPP_TERMINATE))
812 {
813 cmhPPP_Terminate(DWN);
814 }
815 else if (wap_state > Wap_Not_Init AND
816 wap_state <= UDPA_Deactivation)
817 {
818 cmhPPP_Terminated(); /* Trigger termination of TCPIP if PPP did not yet start (ACI-FIX-9317)*/
819 }
820 }
821 break;
822 #endif /* of WAP || FF_PPP || SAT E */
823
824 case(TRANS_CALL):
825 case(NON_TRANS_CALL):
826 if( ccShrdPrm.datStat NEQ DS_IDL )
827 {
828 ccShrdPrm.datStat = DS_STOP_REQ;
829 if(calltype EQ TRANS_CALL)
830 {
831 cmhTRA_Deactivate ();
832 }
833 else
834 {
835 cmhL2R_Deactivate ();
836 }
837 }
838 break;
839 #endif /* FAX_AND_DATA */
840
841 default:
842 break;
843 } /* end switch */
844 } /* end switch */
845
846 LOCAL void cmhCC_CallDisc_userinitiated ( SHORT cId )
847 {
848 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
849 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
850 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
851 #ifdef FF_PSI
852 T_ACI_DTI_PRC_PSI *src_infos = NULL;
853 #endif /*FF_PSI*/
854 UBYTE cmdBuf; /* buffers current command */
855 UBYTE srcBuf; /* buffers current command source */
856 BOOL dtr_clearcall = FALSE;
857
858 TRACE_FUNCTION("cmhCC_CallDisc_userinitiated");
859
860 /* process event for H and +CHUP command */
861 pCCCmdPrm = &cmhPrm[ctb->curSrc].ccCmdPrm;
862
863 /* reset CMOD to single mode */
864 ccShrdPrm.CMODmode = CMOD_MOD_Single;
865
866 call_disconnected_data_call(calltype, cId);
867
868 cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf);
869
870 /* if ATH before the call is connected, the flag must be cleared */
871 cmhCC_tstAndUnflagCall (cId, &(pCCCmdPrm -> mltyCncFlg));
872
873 /* check if disconnect is expected */
874 if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyDscFlg)))
875 {
876 #if defined (FF_WAP) || defined (FF_SAT_E)
877 /* Check if the WAP stack is down */
878 if((pCCCmdPrm -> mltyDscFlg EQ 0) AND
879 (ccShrdPrm.wapStat EQ CC_WAP_STACK_DOWN))
880 #else
881 if( pCCCmdPrm -> mltyDscFlg EQ 0 )
882 #endif /* WAP || SAT E */
883 /****************/
884 /* if last call */
885 /****************/
886 {
887 #ifdef SIM_TOOLKIT
888 if( ctb->SATinv )
889 {
890 cmhSAT_StartPendingCall( );
891 }
892 else
893 #endif /* SIM_TOOLKIT */
894 {
895 if (cmdBuf EQ AT_CMD_Z)
896 {
897 cmh_Reset ( (T_ACI_CMD_SRC)srcBuf, TRUE );
898 R_AT(RAT_Z, (T_ACI_CMD_SRC)srcBuf)();
899 }
900 #if defined (FF_PSI) AND defined (DTI)
901 src_infos = find_element (psi_src_params, srcBuf, cmhPSItest_srcId);
902 if (src_infos EQ NULL)
903 #endif /*FF_PSI*/
904 #ifdef UART
905 {
906 if (uartShrdPrm.dtr_clearcall EQ TRUE)
907 {
908 uartShrdPrm.dtr_clearcall = FALSE;
909 dtr_clearcall = TRUE;
910 }
911 }
912 #endif /*UART*/
913 #if defined (FF_PSI) AND defined (DTI)
914 else if (psiShrdPrm.dtr_clearcall EQ TRUE)
915 {
916 psiShrdPrm.dtr_clearcall = FALSE;
917 dtr_clearcall = TRUE;
918 }
919 #endif /*FF_PSI*/
920 /* To avoid the redudancy of the code */
921 /* If UART and PSI is disabled, still OK has to be sent to MMI */
922 if (dtr_clearcall)
923 {
924 R_AT( RAT_NO_CARRIER,(T_ACI_CMD_SRC)srcBuf ) ( cmdBuf, cId+1 );
925 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf,
926 RAT_NO_CARRIER, (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1), BS_SPEED_NotPresent, CME_ERR_NotPresent );
927 }
928 else
929 {
930 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf );
931 /* log result */
932 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf,
933 RAT_OK, (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1), BS_SPEED_NotPresent,CME_ERR_NotPresent );
934 }
935 }
936 }
937 }
938
939 /* inform call owner about disconnect */
940 if( srcBuf EQ ctb->calOwn
941 #ifdef SIM_TOOLKIT
942 AND
943 !ctb->SATinv )
944 #else
945 )
946 #endif
947 {
948 /* do nothing: owner knows already... */
949 /* EXCEPT if !ctb->SATinv: a SAT call setup has been started, and all previous
950 calls had to be disconnected (because of SAT command qualifer) */
951 }
952 else
953 {
954 R_AT( RAT_NO_CARRIER, (T_ACI_CMD_SRC)ctb->calOwn ) ( AT_CMD_NONE, cId+1 );
955 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_NO_CARRIER, (T_ACI_AT_CMD)cmdBuf,
956 (SHORT)(cId+1), BS_SPEED_NotPresent, CME_ERR_NotPresent);
957 }
958 }
959
960 /* process disconnection of an held call: +CHLD command context */
961 LOCAL void cmhCC_CallDisc_heldcall ( SHORT cId )
962 {
963 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
964 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
965 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
966 UBYTE cmdBuf; /* buffers current command */
967 UBYTE srcBuf; /* buffers current command source */
968 UBYTE cmd_id = 0; /* Command scr id */
969
970 TRACE_FUNCTION("cmhCC_CallDisc_heldcall");
971
972 pCCCmdPrm = &cmhPrm[ctb->curSrc].ccCmdPrm;
973
974 cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf);
975
976 if( pCCCmdPrm -> mltyDscFlg EQ 0 AND
977 pCCCmdPrm -> mltyCncFlg EQ 0 ) /* if last call */
978 {
979 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf );
980
981 /* log result */
982 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_OK,
983 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1), BS_SPEED_NotPresent, CME_ERR_NotPresent );
984 }
985 /* check if disconnect is expected */
986 else if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyDscFlg)))
987 {
988 if( pCCCmdPrm -> CHLDmode EQ CHLD_MOD_RelActAndAcpt AND
989 pCCCmdPrm -> mltyCncFlg AND pCCCmdPrm -> mltyDscFlg EQ 0 )
990 {
991 process_CHLDaddInfo( srcBuf, DISCONNECT_HELD );
992 }
993 else if( pCCCmdPrm -> CHLDmode EQ CHLD_MOD_Ect )
994 {
995 cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyCncFlg)); /* now disconnected */
996 }
997
998 if( pCCCmdPrm -> mltyDscFlg EQ 0 AND
999 pCCCmdPrm -> mltyCncFlg EQ 0 ) /* if last call */
1000 {
1001 /* Reset the CHLDmode to default value */
1002 if( pCCCmdPrm -> CHLDmode EQ CHLD_MOD_Ect )
1003 {
1004 pCCCmdPrm -> CHLDmode = CHLD_MOD_NotPresent;
1005 }
1006 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf );
1007
1008 /* log result */
1009 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_OK,
1010 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1),BS_SPEED_NotPresent, CME_ERR_NotPresent );
1011 }
1012 }
1013 /* check if disconnect is unexpected */
1014 else if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyCncFlg)))
1015 {
1016 if( pCCCmdPrm -> CHLDmode EQ CHLD_MOD_HldActAndAcpt AND
1017 pCCCmdPrm -> mltyCncFlg AND pCCCmdPrm -> mltyDscFlg EQ 0 )
1018 {
1019 process_CHLDaddInfo( srcBuf, DISCONNECT_HELD );
1020 }
1021 else
1022 {
1023 pCCCmdPrm -> mltyCncFlg = 0; /* unflag calls */
1024
1025 R_AT( RAT_CME, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf, CME_ERR_NotPresent );
1026
1027 /* log result */
1028 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_CME, (T_ACI_AT_CMD)cmdBuf,
1029 -1, BS_SPEED_NotPresent, CME_ERR_NotPresent );
1030 }
1031 }
1032
1033 /* inform all the sources about call disconnect */
1034 for( cmd_id = 0; cmd_id < CMD_SRC_MAX; cmd_id++ )
1035 {
1036 R_AT( RAT_NO_CARRIER, cmd_id )( AT_CMD_NONE, cId+1 );
1037 }
1038 }
1039
1040 /* process event for the +CTFR command.*/
1041 LOCAL void cmhCC_CallDisc_transferedcall ( SHORT cId )
1042 {
1043 T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
1044 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
1045 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1046 UBYTE cmdBuf; /* buffers current command */
1047 UBYTE srcBuf; /* buffers current command source */
1048 RAT_ID rat_id;
1049 T_ACI_CME_ERR cme_err;
1050
1051 TRACE_FUNCTION("cmhCC_CallDisc_transferedcall");
1052
1053 /* Get a pointer to the appropriate CC call table entry */
1054 pCCCmdPrm = &cmhPrm[ctb->curSrc].ccCmdPrm;
1055
1056 /* End of command execution here */
1057 cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf);
1058
1059 (void)cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyDscFlg));
1060
1061 switch (ctb->CDStat)
1062 {
1063 case CD_Succeeded:
1064 rat_id = RAT_OK;
1065 cme_err = CME_ERR_NotPresent;
1066 break;
1067
1068 case CD_Requested: /* No answer from the network */
1069 rat_id = RAT_CME;
1070 cme_err = CME_ERR_Timeout;
1071 break;
1072
1073 case CD_Failed: /* SS transaction failed */
1074 rat_id = RAT_CME;
1075 cme_err = CME_ERR_OpNotSupp;
1076 break;
1077
1078 default: /* Unexpected here */
1079 rat_id = RAT_CME;
1080 cme_err = CME_ERR_Unknown;
1081 break;
1082 }
1083
1084 if(rat_id EQ RAT_OK)
1085 {
1086 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf );
1087 }
1088 else if(rat_id EQ RAT_CME)
1089 {
1090 R_AT( RAT_CME, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf, cme_err );
1091 }
1092 cmh_logRslt( (T_ACI_CMD_SRC)srcBuf, rat_id, (T_ACI_AT_CMD)cmdBuf,
1093 (SHORT)(cId+1), BS_SPEED_NotPresent,cme_err );
1094
1095 ctb->CDStat = NO_VLD_CD;
1096 }
1097
1098 GLOBAL void cmhCC_CallDisconnected ( SHORT cId )
1099 {
1100 #if defined(FF_GPF_TCPIP)
1101 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
1102 #endif /* FF_GPF_TCPIP */
1103 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1104
1105 TRACE_FUNCTION ("cmhCC_CallDisconnected()");
1106
1107 /* inform advice of charge module */
1108 aoc_info (cId, AOC_STOP_TIME);
1109
1110 #if defined(FF_GPF_TCPIP)
1111 /* Needed if user stops call setup before app got connection conf */
1112 if (calltype EQ TCPIP_CALL)
1113 {
1114 T_DCM_STATUS_IND_MSG msg;
1115 msg.hdr.msg_id = DCM_NEXT_CMD_STOP_MSG;
1116 msg.result = DCM_PS_CONN_BROKEN;
1117 dcm_send_message(msg, DCM_SUB_WAIT_SATDN_CNF);
1118 }
1119 #endif /* FF_GPF_TCPIP */
1120
1121 /*
1122 *----------------------------------------------------------------
1123 * call progress information
1124 *----------------------------------------------------------------
1125 */
1126 /* Implements Measure 207 */
1127 cmhCC_Call_Progress_Information( cId, CPI_MSG_Disc, ctb->curCs );
1128
1129 /*************************
1130 call was not serviced yet
1131 ***************************/
1132 /* Implements Measure 32 */
1133 if (cmhCC_check_isCallServiced( cId ) EQ TRUE )
1134 {
1135 return;
1136 }
1137
1138 /*************************
1139 check for command context
1140 ***************************/
1141 switch( ctb->curCmd )
1142 {
1143 case( AT_CMD_NONE ):
1144 case( AT_CMD_A ):
1145 case( AT_CMD_D ):
1146 case( AT_CMD_ABRT ):
1147 cmhCC_CallDisc_connectingphase(cId);
1148 break;
1149
1150 case( AT_CMD_H ):
1151 case( AT_CMD_Z ):
1152 case( AT_CMD_CHUP ):
1153
1154 #ifdef FF_FAX
1155 case( AT_CMD_FKS ):
1156 case( AT_CMD_FDT ):
1157 case( AT_CMD_FDR ):
1158 #endif /* FF_FAX */
1159
1160 cmhCC_CallDisc_userinitiated(cId);
1161 break;
1162
1163 case( AT_CMD_CHLD ):
1164 cmhCC_CallDisc_heldcall(cId);
1165 break;
1166
1167 case( AT_CMD_CTFR ):
1168 cmhCC_CallDisc_transferedcall(cId);
1169 break;
1170 } /* switch */
1171
1172 /* PATCH BE 03.07.00
1173 * DO NOT declare the call table entry as unused:
1174 do not free call table at this time then every second MTC will fail if early
1175 assignment is used. */
1176
1177 return;
1178 }
1179
1180 /*
1181 +-------------------------------------------------------------------+
1182 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
1183 | ROUTINE : cmhCC_CallReleased |
1184 +-------------------------------------------------------------------+
1185
1186 PURPOSE : call is released
1187
1188 */
1189
1190 GLOBAL void cmhCC_CallReleased ( SHORT cId )
1191 {
1192 UBYTE cmdBuf; /* buffers current command */
1193 UBYTE srcBuf; /* buffers current command source */
1194 T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
1195 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
1196 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1197
1198 TRACE_FUNCTION ("cmhCC_CallReleased()");
1199
1200 /* inform advice of charge module */
1201 aoc_info (cId, AOC_STOP_TIME);
1202
1203 #if defined(FF_GPF_TCPIP)
1204 /* This will happen if network got lost during a CSD call */
1205 if (calltype EQ TCPIP_CALL)
1206 {
1207 T_DCM_STATUS_IND_MSG msg;
1208 msg.hdr.msg_id = DCM_ERROR_IND_MSG;
1209 msg.result = DCM_PS_CONN_BROKEN;
1210 dcm_send_message(msg, DCM_SUB_WAIT_SATDN_CNF);
1211 }
1212 #endif /* FF_GPF_TCPIP */
1213
1214 /* check for command context */
1215 switch( ctb->curCmd )
1216 {
1217 case( AT_CMD_A ):
1218 case( AT_CMD_D ):
1219 case( AT_CMD_NONE ):
1220 /* process event for A, D or no command */
1221
1222 /* handling for CCBS prolonged session */
1223
1224 if( ctb->curSrc NEQ CMD_SRC_NONE )
1225 {
1226 cmhCC_tstAndUnflagCall( cId, &cmhPrm[ctb->curSrc].ccCmdPrm.mltyCncFlg );
1227 cmhCC_tstAndUnflagCall( cId, &cmhPrm[ctb->curSrc].ccCmdPrm.mltyDscFlg );
1228 }
1229
1230 if (ctb->CCBSstat EQ CCBSS_PSSBL )
1231 {
1232 cmhrat_ccbs (CMD_SRC_MAX, CCBS_IND_PossibilityTimedOut,
1233 CCBS_STAT_NotPresent, NULL );
1234 break; /* skip the rest */
1235 }
1236 if (ctb->CCBSstat EQ CCBSS_REQ)
1237 {
1238 break; /* skip the rest */
1239 }
1240 if (ctb->calType EQ CT_NI_MOC)
1241 {
1242 cmhrat_ccbs( CMD_SRC_MAX, CCBS_IND_RecallTimedOut,
1243 CCBS_STAT_NotPresent, NULL );
1244 break; /* skip the rest */
1245 }
1246
1247 /* call clean up */
1248 switch( calltype )
1249 {
1250 case( VOICE_CALL ):
1251 ;
1252 break;
1253
1254 #ifdef FF_GPF_TCPIP
1255 case( TCPIP_CALL ):
1256 if( ccShrdPrm.datStat NEQ DS_IDL )
1257 {
1258 ccShrdPrm.datStat = DS_STOP_REQ;
1259 pppShrdPrm.state = PPP_UNDEFINED; /* Otherwise PPP and TCPIP doesn't go down well */
1260 cmhPPP_Terminate(DWN);
1261 ctb->curCmd = AT_CMD_NONE;
1262 }
1263 break;
1264 #endif /* FF_GPF_TCPIP */
1265
1266 #if defined (FAX_AND_DATA) AND defined (DTI)
1267 case( TRANS_CALL ):
1268 if( ccShrdPrm.datStat NEQ DS_IDL )
1269 {
1270 ccShrdPrm.datStat = DS_STOP_REQ;
1271 cmhTRA_Deactivate ();
1272 }
1273 break;
1274
1275 case( NON_TRANS_CALL ):
1276 if( ccShrdPrm.datStat NEQ DS_IDL )
1277 {
1278 ccShrdPrm.datStat = DS_STOP_REQ;
1279 cmhL2R_Deactivate ();
1280 }
1281 break;
1282
1283 #ifdef CO_UDP_IP
1284 case( UDPIP_CALL ):
1285 if( ccShrdPrm.datStat NEQ DS_IDL )
1286 {
1287 ccShrdPrm.datStat = DS_STOP_REQ;
1288 cmhPPP_Terminate(DWN);
1289 ctb->curCmd = AT_CMD_NONE;
1290 }
1291 break;
1292 #endif /* CO_UDP_IP */
1293
1294 #ifdef FF_FAX
1295 case( FAX_CALL ):
1296 if( ccShrdPrm.datStat NEQ DS_IDL )
1297 {
1298 ccShrdPrm.datStat = DS_STOP_REQ;
1299 cmhT30_Deactivate ();
1300 }
1301 #endif /* FF_FAX */
1302 #endif /* FAX_AND_DATA */
1303
1304 }
1305 cmhCC_SndDiscRsn( cId );
1306 break;
1307
1308 case( AT_CMD_H ):
1309 case( AT_CMD_Z ):
1310 case( AT_CMD_CHUP ):
1311 case( AT_CMD_ABRT ):
1312 case( AT_CMD_CHLD ):
1313
1314 #ifdef FF_FAX
1315 case( AT_CMD_FKS ):
1316 case( AT_CMD_FDT ):
1317 case( AT_CMD_FDR ):
1318 #endif
1319 /*
1320 *----------------------------------------------------------------
1321 * process event for H, Z and +CHUP command
1322 *----------------------------------------------------------------
1323 */
1324 /*
1325 * Bugfix for DISCONNECT_IND in CC U3 with PROGRESS_IND #8
1326 */
1327 cmdBuf = ctb->curCmd;
1328 srcBuf = ctb->curSrc;
1329 pCCCmdPrm = &cmhPrm[srcBuf].ccCmdPrm;
1330
1331 cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm->mltyCncFlg) );
1332 cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm->mltyDscFlg) );
1333
1334 if ( cmdBuf EQ AT_CMD_Z AND
1335 pCCCmdPrm -> mltyDscFlg EQ 0 )
1336 {
1337 cmh_Reset ( (T_ACI_CMD_SRC)srcBuf, TRUE );
1338 R_AT( RAT_Z, (T_ACI_CMD_SRC)srcBuf)();
1339 }
1340
1341 cmhCC_PrepareCmdEnd (cId, NULL, NULL);
1342
1343 if (ctb->curCmd NEQ AT_CMD_CHLD) /* Do not emmit OK for CHLD since this would
1344 occour in multiple OKs for a multi-party call */
1345 {
1346 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf );
1347 }
1348
1349 /* log result */
1350 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_OK, (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1),
1351 BS_SPEED_NotPresent,CME_ERR_NotPresent );
1352 break;
1353 }
1354
1355 /* call progress information */
1356 /* Implements Measure 207 */
1357 cmhCC_Call_Progress_Information( cId, CPI_MSG_Rls, ctb->curCs );
1358
1359 if (rdlPrm.rdlcId NEQ cId)
1360 { /* if redialling is active no clean cId entry */
1361 /* declare the call table entry as unused */
1362 psaCC_FreeCtbNtry (cId);
1363 }
1364 return;
1365 }
1366
1367 /*
1368 +-------------------------------------------------------------------+
1369 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
1370 | ROUTINE : cmhCC_CallReleaseIndication |
1371 +-------------------------------------------------------------------+
1372
1373 PURPOSE : call release indication to give out correct call process information
1374 interface so that psa function can report a release ind
1375 */
1376
1377 GLOBAL void cmhCC_CPIReleaseMsg ( SHORT cId )
1378 {
1379 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1380 TRACE_FUNCTION ("cmhCC_CPIReleaseMsg()");
1381
1382 /* call progress information */
1383 /* Implements Measure 207 */
1384 cmhCC_Call_Progress_Information( cId, CPI_MSG_Rls, ctb->curCs );
1385
1386 return;
1387 }
1388
1389 /*
1390 +-------------------------------------------------------------------+
1391 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
1392 | ROUTINE : cmhCC_CPIrejectMsg |
1393 +-------------------------------------------------------------------+
1394
1395 PURPOSE : interface so that psa function can report a reject ind.
1396
1397 */
1398 GLOBAL void cmhCC_CPIrejectMsg ( SHORT cId )
1399 {
1400 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1401
1402 TRACE_FUNCTION ("cmhCC_CPIrejectMsg()");
1403
1404 /* Implements Measure 207 */
1405 cmhCC_Call_Progress_Information( cId, CPI_MSG_Rjct, ctb->curCs );
1406 /*************************
1407 call was not serviced yet
1408 ***************************/
1409 /* Implements Measure 32 */
1410 if (cmhCC_check_isCallServiced( cId ) EQ TRUE)
1411 {
1412 return;
1413 }
1414
1415 return;
1416 }
1417
1418 /*
1419 +-------------------------------------------------------------------+
1420 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
1421 | ROUTINE : cmhCC_CallModified |
1422 +-------------------------------------------------------------------+
1423
1424 PURPOSE : call was modified
1425
1426 */
1427
1428 GLOBAL void cmhCC_CallModified ( SHORT cId )
1429 {
1430 #if defined (FAX_AND_DATA)
1431 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1432 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
1433 UBYTE cmdBuf; /* buffers current command */
1434 UBYTE srcBuf; /* buffers current command source */
1435
1436 TRACE_FUNCTION ("cmhCC_CallModified()");
1437
1438 /* check for command context */
1439 switch (ctb->curCmd )
1440 {
1441 case( AT_CMD_D ):
1442 case( AT_CMD_A ):
1443 case( AT_CMD_H ):
1444 /* process event for D, A and H command */
1445 cmdBuf = ctb->curCmd;
1446 srcBuf = ctb->curSrc;
1447 break;
1448
1449 default:
1450 cmdBuf = AT_CMD_NONE;
1451 srcBuf = ctb->calOwn;
1452 break;
1453 }
1454
1455 /* determine modifaction status */
1456 switch (ctb->rslt)
1457 {
1458 /* successful modification */
1459 case( MNCC_CAUSE_MODIFY_SUCCESS ):
1460
1461 switch( calltype )
1462 {
1463 /* modified to speech call */
1464 case( VOICE_CALL ):
1465 cmhCC_PrepareCmdEnd (cId, NULL, NULL);
1466
1467 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf );
1468
1469 /* log result */
1470 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_OK,
1471 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1), BS_SPEED_NotPresent,CME_ERR_NotPresent );
1472 break;
1473
1474 /* modified to transparent or non-transparent or fax data call */
1475 case( TRANS_CALL ):
1476 case( NON_TRANS_CALL ):
1477 case( FAX_CALL ):
1478 ccShrdPrm.datStat = DS_ACT_REQ;
1479
1480 if( cmhRA_Activate ( (T_ACI_CMD_SRC)srcBuf, (T_ACI_AT_CMD)cmdBuf, cId ) NEQ AT_EXCT )
1481 {
1482 ctb->nrmCs = MNCC_CAUSE_CALL_CLEAR;
1483 psaCC_ClearCall (cId);
1484 }
1485 break;
1486 }
1487 break;
1488
1489 /* unsuccessful modification */
1490 case( MNCC_CAUSE_MS_TIMER ):
1491 default: /* network can send any cause */
1492
1493 TRACE_EVENT_P1 ("MODIFICATION FAILURE: cause=%d",ctb->rslt);
1494
1495
1496 R_AT( RAT_CME, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf, CME_ERR_NotPresent );
1497
1498 /* log result */
1499 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_CME, (T_ACI_AT_CMD)cmdBuf, -1,
1500 BS_SPEED_NotPresent,CME_ERR_NotPresent );
1501
1502 if( calltype EQ TRANS_CALL OR
1503 calltype EQ NON_TRANS_CALL OR
1504 calltype EQ FAX_CALL )
1505 {
1506 /* back to transparent or non-transparent or fax data call */
1507 ccShrdPrm.datStat = DS_REST_REQ;
1508
1509 if( cmhRA_Activate ( (T_ACI_CMD_SRC)srcBuf, (T_ACI_AT_CMD)cmdBuf, cId ) NEQ AT_EXCT )
1510 {
1511 ctb->nrmCs = MNCC_CAUSE_CALL_CLEAR;
1512 psaCC_ClearCall (cId);
1513 }
1514 }
1515 break;
1516 }
1517 #endif /* FAX_AND_DATA */
1518 }
1519
1520 /*
1521 +-------------------------------------------------------------------+
1522 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
1523 | ROUTINE : cmhCC_DTMFsent |
1524 +-------------------------------------------------------------------+
1525
1526 PURPOSE : confirmation for sent DTMF
1527
1528 */
1529
1530 LOCAL void dtmf_sent_after_vts ( SHORT cId )
1531 {
1532 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1533 UBYTE current_cmd_source = ctb->dtmfSrc; /* buffers current command source */
1534
1535 TRACE_FUNCTION ("dtmf_sent_after_vts()");
1536
1537 ctb->dtmfCmd = AT_CMD_NONE;
1538 ctb->dtmfSrc = (T_OWN)CMD_SRC_NONE;
1539
1540 ccShrdPrm.dtmf.cId = NO_ENTRY;
1541 ccShrdPrm.dtmf.cnt = 0;
1542
1543 if ((GET_CAUSE_VALUE(ctb->nrmCs) NEQ NOT_PRESENT_8BIT) AND
1544 (ctb->nrmCs NEQ MNCC_CAUSE_DTMF_START_SUCCESS) AND
1545 (ctb->nrmCs NEQ MNCC_CAUSE_DTMF_STOP_SUCCESS))
1546 {
1547 TRACE_EVENT_P1("DTMF response cause value: %d", ctb->nrmCs);
1548 R_AT( RAT_CME, (T_ACI_CMD_SRC)current_cmd_source ) ( AT_CMD_VTS, CME_ERR_NotPresent );
1549 return;
1550 }
1551
1552 R_AT( RAT_OK, (T_ACI_CMD_SRC)current_cmd_source ) ( AT_CMD_VTS );
1553 }
1554
1555 LOCAL void dtmf_sent_within_number ( SHORT cId )
1556 {
1557 BOOL dtmf_sent; /* result of sending of next DTMF char */
1558
1559 TRACE_FUNCTION ("dtmf_sent_within_number()");
1560
1561 if ((ccShrdPrm.dtmf.cId NEQ cId) OR
1562 !is_call_ok_for_dtmf(cId))
1563 {
1564 TRACE_EVENT_P2("Wrong cId for send DTMF. ccShrdPrm.dtmf.cId: %d, cId: %d", ccShrdPrm.dtmf.cId, cId);
1565 return;
1566 }
1567
1568 while( ccShrdPrm.dtmf.cnt AND
1569 ccShrdPrm.dtmf.cur < ccShrdPrm.dtmf.cnt )
1570 {
1571 dtmf_sent = cmhCC_SendDTMFdig ( AT_CMD_NONE,
1572 cId,
1573 ccShrdPrm.dtmf.dig[ccShrdPrm.dtmf.cur],
1574 MNCC_DTMF_MOD_AUTO );
1575 ccShrdPrm.dtmf.cur++;
1576 if( dtmf_sent )
1577 {
1578 return;
1579 }
1580 }
1581
1582 TRACE_EVENT_P1("End of sending DTMF tones: %d", ccShrdPrm.dtmf.dig[ccShrdPrm.dtmf.cur]);
1583 ccShrdPrm.dtmf.cnt = ccShrdPrm.dtmf.cur = 0;
1584 ccShrdPrm.dtmf.cId = NO_ENTRY;
1585 }
1586
1587 GLOBAL void cmhCC_DTMFsent ( SHORT cId )
1588 {
1589 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1590
1591 TRACE_FUNCTION ("cmhCC_DTMFsent()");
1592
1593 switch( ctb->dtmfCmd )
1594 {
1595 case( AT_CMD_VTS ):
1596 dtmf_sent_after_vts(cId);
1597 return;
1598
1599 case( AT_CMD_NONE ):
1600 dtmf_sent_within_number(cId);
1601 return;
1602
1603 default:
1604 TRACE_EVENT_P1("Unexpected DTMF command value: %d", ctb->dtmfCmd);
1605 break;
1606 }
1607 }
1608
1609
1610 /*
1611 This will be called when the call was disconnected while sending DTMF tones
1612
1613 */
1614 GLOBAL void cmhCC_DTMFstopped ( SHORT cId )
1615 {
1616 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1617
1618 TRACE_FUNCTION ("cmhCC_DTMFstopped()");
1619
1620 switch( ctb->dtmfCmd )
1621 {
1622 case( AT_CMD_VTS ):
1623 TRACE_EVENT ("DTMF stopped within VTS");
1624 R_AT( RAT_CME,(T_ACI_CMD_SRC)ctb->dtmfSrc )
1625 ( AT_CMD_VTS, CME_ERR_Unknown );
1626 return;
1627
1628 case( AT_CMD_NONE ):
1629 TRACE_EVENT ("DTMF stopped within NONE");
1630
1631 return;
1632
1633 default:
1634 TRACE_EVENT_P1("Unexpected DTMF command value: %d", ctb->dtmfCmd);
1635 break;
1636 }
1637 }
1638
1639
1640 #if 0 // HM 11-May-2005: Dead code
1641 /*
1642 +-------------------------------------------------------------------+
1643 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
1644 | ROUTINE : cmhCC_DisconnectCall |
1645 +-------------------------------------------------------------------+
1646
1647 PURPOSE : request to disconnect the call (in-band tones available)
1648
1649 */
1650
1651 GLOBAL void cmhCC_DisconnectCall ( SHORT cId )
1652 {
1653 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1654 T_CC_CMD_PRM *pCCCmdPrm; /* points to CC command parameters */
1655 UBYTE cmdBuf; /* buffers current command */
1656 UBYTE srcBuf; /* buffers current command source */
1657
1658 TRACE_FUNCTION ("cmhCC_DisconnectCall()");
1659
1660 /* check for command context */
1661 switch (ctb->curCmd)
1662 {
1663 case( AT_CMD_NONE ):
1664 case( AT_CMD_D ):
1665 case( AT_CMD_A ):
1666 /*
1667 *----------------------------------------------------------------
1668 * process event for D, A and no command
1669 *----------------------------------------------------------------
1670 */
1671 /* for data calls proceed with call completion */
1672 if( cmhCC_getcalltype(cId) NEQ VOICE_CALL )
1673 {
1674 psaCC_ClearCall (cId);
1675 }
1676 break;
1677
1678 case( AT_CMD_H ):
1679 case( AT_CMD_Z ):
1680 case( AT_CMD_CHUP ):
1681
1682 /*
1683 *----------------------------------------------------------------
1684 * process event for H, Z and +CHUP command
1685 *----------------------------------------------------------------
1686 */
1687 cmdBuf = ctb->curCmd;
1688 srcBuf = ctb->curSrc;
1689
1690 psaCC_ClearCall (cId);
1691
1692 cmhCC_PrepareCmdEnd (cId, NULL, NULL);
1693
1694 pCCCmdPrm = &cmhPrm[srcBuf].ccCmdPrm;
1695
1696 if(cmdBuf EQ AT_CMD_Z AND
1697 pCCCmdPrm -> mltyDscFlg EQ 0 )
1698 {
1699 cmh_Reset ( srcBuf, TRUE );
1700 R_AT( RAT_Z, srcBuf)();
1701 }
1702
1703 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf ) ( (T_ACI_AT_CMD)cmdBuf );
1704
1705 /* log result */
1706 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_OK,
1707 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1), BS_SPEED_NotPresent, CME_ERR_NotPresent );
1708 break;
1709 }
1710
1711 return;
1712 }
1713 #endif /* #if 0 */
1714
1715 /*
1716 +-------------------------------------------------------------------+
1717 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
1718 | ROUTINE : cmhCC_IncomingCall |
1719 +-------------------------------------------------------------------+
1720
1721 PURPOSE : indication of a mobile terminated call
1722
1723 */
1724
1725 GLOBAL void cmhCC_IncomingCall ( SHORT cId )
1726 {
1727 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
1728 SHORT idx; /* holds index counter */
1729 T_ACI_CRING_MOD mode; /* holds mode of call */
1730 T_ACI_CRING_SERV_TYP type1, type2; /* holds types of bearer services */
1731 CHAR numBuf[MAXIMUM(MNCC_MAX_CC_CALLING_NUMBER, MNCC_MAX_CC_REDIR_NUMBER)+1];
1732 /* buffers calling number + '\0' */
1733 CHAR subBuf[MNCC_SUB_LENGTH+1]; /* buffers subaddress 'subaddress\0' */
1734 T_ACI_TOA toaBuf; /* buffers type of address */
1735 T_ACI_TOS tosBuf; /* buffers type of subaddress */
1736 USHORT listcounter;
1737 T_ACI_LIST *msg2send;
1738
1739 TRACE_FUNCTION ("cmhCC_IncomingCall()");
1740
1741 /*
1742 *-------------------------------------------------------------------
1743 * ring for call, if no call is in use
1744 *-------------------------------------------------------------------
1745 */
1746 if( ! psaCC_ctbCallInUse() )
1747 {
1748
1749 switch (ctb->rptInd) /* determine call mode */
1750 {
1751 case( MNCC_RI_NOT_PRES ):
1752 case( MNCC_RI_SEQUENTIAL ):
1753 mode = CRING_MOD_Direct;
1754 break;
1755 case( MNCC_RI_CIRCULAR ):
1756 mode = CRING_MOD_Alternate;
1757 break;
1758
1759 default:
1760 TRACE_EVENT("UNEXP REPEAT INDICATOR IN CTB");
1761 mode = CRING_MOD_NotPresent;
1762 break;
1763 }
1764
1765 /* determine 1st service */
1766 type1 = (T_ACI_CRING_SERV_TYP)cmhCC_GetCallType_from_bearer( &ctb->BC[0] );
1767
1768 /* determine 2nd service */
1769 type2 = (T_ACI_CRING_SERV_TYP)cmhCC_GetCallType_from_bearer( &ctb->BC[1] );
1770
1771 #ifdef FF_ATI
1772 io_setRngInd (IO_RING_ON, type1, type2); /* V.24 Ring Indicator Line */
1773 #endif
1774
1775 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
1776 {
1777 if (ctb->prgDesc EQ MNCC_PROG_NOT_PRES)
1778 {
1779 R_AT( RAT_CPI, (T_ACI_CMD_SRC)idx )
1780 ( cId+1,
1781 CPI_MSG_Setup,
1782 (ctb->inBndTns)? CPI_IBT_True: CPI_IBT_False,
1783 (ccShrdPrm.TCHasg)? CPI_TCH_True: CPI_TCH_False,
1784 ctb->curCs );
1785 }
1786 R_AT( RAT_CRING, (T_ACI_CMD_SRC)idx )( mode, type1, type2 );
1787
1788 /* calling line presentation, if no call is in use */
1789
1790 /* check of presentation indicator removed, due to the fact that
1791 * other mobiles show the same behaviour.
1792 if( ctb->clgPty.present NEQ PRES_NUMB_NOT_AVAIL ){} */
1793
1794 R_AT( RAT_CLIP, (T_ACI_CMD_SRC)idx )
1795 ( CLIP_STAT_NotPresent,
1796 psaCC_ctbClrAdr2Num( cId, numBuf, sizeof (numBuf) ),
1797 cmhCC_ctbGetClrNumTyp( cId, &toaBuf ),
1798 ctb->clgPty.present,
1799 psaCC_ctbClrAdr2Sub( cId, subBuf ),
1800 cmhCC_ctbGetClrSubTyp( cId, &tosBuf ),
1801 psaCC_ctbGetAlpha( cId ) );
1802
1803 R_AT ( RAT_CDIP, (T_ACI_CMD_SRC)idx )
1804 (psaCC_ctbCldAdr2Num( cId, numBuf, sizeof (numBuf) ),
1805 cmhCC_ctbGetCldNumTyp( cId, &toaBuf ),
1806 psaCC_ctbCldAdr2Sub( cId, subBuf ),
1807 cmhCC_ctbGetCldSubTyp( cId, &tosBuf ));
1808
1809 } /* for */
1810
1811 if (ctb->CDStat EQ CD_Notified)
1812 {
1813 send_CSSX_notification(cId,
1814 CSSX_CODE_DeflectedCall,
1815 ACI_NumParmNotPresent,
1816 psaCC_ctbRdrAdr2Num( cId, numBuf, sizeof (numBuf) ),
1817 cmhCC_ctbGetRdrNumTyp( cId, &toaBuf ),
1818 psaCC_ctbRdrAdr2Sub( cId, subBuf ),
1819 cmhCC_ctbGetRdrSubTyp( cId, &tosBuf));
1820 }
1821
1822 if (ctb->CDStat EQ CD_Notified)
1823 {
1824 psaCC_FreeRdrPty (cId);
1825 ctb->CDStat = NO_VLD_CD;
1826 }
1827 /* check for TTY service */
1828 cmhCC_TTY_Control ( cId, TTY_START );
1829
1830 /* Find out if there is any MNCC_FACILITY_IND stored */
1831 listcounter = 0;
1832 if ((listcounter = get_list_count(ccShrdPrm.facility_list)) > 0)
1833 {
1834 for (;listcounter > 0 ; listcounter --)
1835 {
1836 msg2send = remove_first_element(ccShrdPrm.facility_list);
1837
1838 /* Send MNCC_FACILITY_IND */
1839 psa_mncc_facility_ind((T_MNCC_FACILITY_IND *)msg2send);
1840 }
1841 }
1842
1843 } /* endif */
1844
1845
1846 /*
1847 *-------------------------------------------------------------------
1848 * call waiting indication, if a call is in use
1849 *-------------------------------------------------------------------
1850 */
1851 else
1852 {
1853 /* check of presentation indicator removed, due to the fact that
1854 other mobiles show the same behaviour.
1855 if( ctb->clgPty.present NEQ PRES_NUMB_NOT_AVAIL ) {} */
1856
1857 if (ctb->CDStat EQ CD_Notified)
1858 {
1859 send_CSSX_notification( cId,
1860 CSSX_CODE_DeflectedCall,
1861 ACI_NumParmNotPresent,
1862 psaCC_ctbRdrAdr2Num( cId, numBuf, sizeof (numBuf) ),
1863 cmhCC_ctbGetRdrNumTyp( cId, &toaBuf ),
1864 psaCC_ctbRdrAdr2Sub( cId, subBuf ),
1865 cmhCC_ctbGetRdrSubTyp( cId, &tosBuf ));
1866 }
1867
1868 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
1869 {
1870 if (ctb->prgDesc EQ MNCC_PROG_NOT_PRES)
1871 {
1872 R_AT( RAT_CPI, (T_ACI_CMD_SRC)idx )
1873 ( cId+1,
1874 CPI_MSG_Setup,
1875 (ctb->inBndTns)? CPI_IBT_True: CPI_IBT_False,
1876 (ccShrdPrm.TCHasg)? CPI_TCH_True: CPI_TCH_False,
1877 ctb->curCs );
1878 }
1879
1880 R_AT( RAT_CCWA, (T_ACI_CMD_SRC)idx )
1881 ( NULL,
1882 psaCC_ctbClrAdr2Num( cId, numBuf, sizeof (numBuf) ),
1883 cmhCC_ctbGetClrNumTyp( cId, &toaBuf ),
1884 ctb->clgPty.present,
1885 cmhCC_GetCallClass( cId ),
1886 psaCC_ctbGetAlpha( cId ) );
1887 }
1888 if (ctb->CDStat EQ CD_Notified)
1889 {
1890 psaCC_FreeRdrPty (cId);
1891 ctb->CDStat = NO_VLD_CD;
1892 }
1893 }
1894 }
1895
1896 /*
1897 +-------------------------------------------------------------------+
1898 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
1899 | ROUTINE : psaCC_Synchronized |
1900 +-------------------------------------------------------------------+
1901
1902 PURPOSE : channel mode has changed or
1903 call reestablishment event received.
1904 If a channel mode change is indicated cId needs not
1905 to be valid.
1906
1907 */
1908
1909 GLOBAL void cmhCC_Synchronized ( SHORT cId )
1910 {
1911 SHORT act_cId; /* holds call identifier */
1912 #if defined (FAX_AND_DATA) AND defined (DTI)
1913 T_CC_CALL_TYPE calltype;
1914 #endif /* of #ifdef FAX_AND_DATA */
1915
1916 TRACE_FUNCTION ("cmhCC_Synchronized()");
1917
1918 /* process event */
1919 switch( ccShrdPrm.syncCs )
1920 {
1921 case( MNCC_CAUSE_CHANNEL_SYNC ): /* change of TCH state */
1922
1923 if( ccShrdPrm.TCHasg EQ TRUE )
1924 {
1925 /* search for an active call */
1926 if((act_cId = psaCC_ctbFindCall( OWN_SRC_INV, CS_ACT, NO_VLD_CT ))
1927 NEQ NO_ENTRY )
1928 {
1929 #if defined (FAX_AND_DATA) AND defined (DTI)
1930 calltype = cmhCC_getcalltype(act_cId);
1931
1932 switch( calltype )
1933 {
1934 #ifdef FF_FAX
1935 case( FAX_CALL ):
1936 switch( ccShrdPrm.datStat )
1937 {
1938 case( DS_ACT ):
1939 case( DS_TCH_MDF ):
1940 ccShrdPrm.datStat = DS_TCH_MDF;
1941 /*
1942 * use entity owner instead of current source, because
1943 * command is out of scope for CC
1944 */
1945 if( cmhRA_Modify ( raEntStat.entOwn, act_cId ) NEQ AT_EXCT )
1946 {
1947 ccShrdPrm.datStat = DS_IDL;
1948 cmhT30_Deactivate();
1949 psaCC_ctb(act_cId)->nrmCs = MNCC_CAUSE_CALL_CLEAR;
1950 psaCC_ClearCall (act_cId);
1951 }
1952 break;
1953
1954 case( DS_IDL ):
1955 ccShrdPrm.datStat = DS_ACT_REQ;
1956 if( cmhRA_Activate ( (T_ACI_CMD_SRC)psaCC_ctb(act_cId)->curSrc,
1957 (T_ACI_AT_CMD)psaCC_ctb(act_cId)->curCmd,
1958 act_cId )
1959 NEQ AT_EXCT )
1960 {
1961 ccShrdPrm.datStat = DS_IDL;
1962 psaCC_ctb(act_cId)->nrmCs = MNCC_CAUSE_CALL_CLEAR;
1963 psaCC_ClearCall (act_cId);
1964 }
1965 }
1966 break;
1967 #endif /* FF_FAX */
1968
1969 case( TRANS_CALL ): /* activate RA */
1970 case( NON_TRANS_CALL ): /* activate RA */
1971 switch( ccShrdPrm.datStat )
1972 {
1973 case( DS_IDL ):
1974 ccShrdPrm.datStat = DS_ACT_REQ;
1975 if( cmhRA_Activate ( (T_ACI_CMD_SRC)psaCC_ctb(act_cId)->curSrc,
1976 (T_ACI_AT_CMD)psaCC_ctb(act_cId)->curCmd,
1977 act_cId )
1978 NEQ AT_EXCT )
1979 {
1980 ccShrdPrm.datStat = DS_IDL;
1981 psaCC_ctb(act_cId)->nrmCs = MNCC_CAUSE_CALL_CLEAR;
1982 psaCC_ClearCall (act_cId);
1983 }
1984 break;
1985
1986 default:
1987 TRACE_EVENT("modify data call ignored");
1988 break;
1989 }
1990 break;
1991
1992 case( UNSUP_DATA_CALL ):
1993 TRACE_EVENT("UNSUPPORTED DATA CALL -> DISC CALL");
1994 psaCC_ctb(act_cId)->nrmCs = MNCC_CAUSE_CALL_CLEAR;
1995 psaCC_ClearCall (act_cId);
1996 break;
1997 }
1998 #endif /* FAX_AND_DATA */
1999 }
2000 }
2001
2002 /* Information about Traffic Channel Assignment should be sent
2003 for all existing act_cIds */
2004 for( act_cId = 0; act_cId < MAX_CALL_NR; act_cId++ )
2005 {
2006 if (ccShrdPrm.ctb[act_cId] NEQ NULL)
2007 {
2008 /* Implements Measure 207 */
2009 cmhCC_Call_Progress_Information( act_cId, CPI_MSG_Sync, psaCC_ctb(act_cId)->curCs );
2010 }
2011 }
2012 break;
2013
2014 case( MNCC_CAUSE_REEST_STARTED ): /* call reestablishment */
2015 case( MNCC_CAUSE_REEST_FINISHED ):
2016 /* Implements Measure#32: Row 81, 82 */
2017 if(ccShrdPrm.syncCs EQ MNCC_CAUSE_REEST_STARTED)
2018 {
2019 TRACE_EVENT("SYNC -> CALL REESTABLISHMENT STARTED");
2020 }
2021 else
2022 {
2023 TRACE_EVENT("SYNC -> CALL REESTABLISHMENT FINISHED");
2024 }
2025 if (psaCC_ctbIsValid (cId))
2026 {
2027 /* Send %CPI notification for call reestablishment */
2028 /* Implements Measure 207 */
2029 cmhCC_Call_Progress_Information( cId, CPI_MSG_Sync, psaCC_ctb(cId)->curCs );
2030 }
2031 else
2032 {
2033 TRACE_ERROR ("No call table entry");
2034 }
2035 break;
2036 }
2037 }
2038
2039 /*
2040 +-------------------------------------------------------------------+
2041 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
2042 | ROUTINE : psaCC_CallHeld |
2043 +-------------------------------------------------------------------+
2044
2045 PURPOSE : call hold result
2046
2047 */
2048
2049 GLOBAL void cmhCC_CallHeld ( SHORT cId )
2050 {
2051 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
2052 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
2053 UBYTE cmdBuf; /* buffers current command */
2054 UBYTE srcBuf; /* buffers current command source */
2055 SHORT addId; /* holds additional call id */
2056 TRACE_FUNCTION ("cmhCC_CallHeld()");
2057
2058 /* check for command context */
2059 switch (ctb->curCmd )
2060 {
2061 case( AT_CMD_D ):
2062 case( AT_CMD_A ):
2063 case( AT_CMD_CHLD ):
2064 break;
2065
2066 default:
2067 TRACE_EVENT_P1("Error: wrong command context: %d", ctb->curCmd);
2068 return; /* wrong command context */
2069 }
2070
2071 cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf);
2072 pCCCmdPrm = &cmhPrm[srcBuf].ccCmdPrm;
2073
2074 /* check result of hold request */
2075 TRACE_EVENT_P1("Hold CNF cause value: %04X", ctb->rslt);
2076 switch( ctb->rslt )
2077 {
2078 case( MNCC_CAUSE_HOLD_SUCCESS ):
2079 case( MNCC_CAUSE_SUCCESS ):
2080 case( MNCC_CAUSE_NO_MS_CAUSE ):
2081
2082 /* Held information displayed if call is on hold */
2083 /* Implements Measure 207 */
2084 cmhCC_Call_Progress_Information( cId, CPI_MSG_Hld, ctb->rslt );
2085
2086 if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyCncFlg)))
2087 {
2088 if((pCCCmdPrm -> CHLDmode EQ CHLD_MOD_HldActExc OR
2089 pCCCmdPrm -> CHLDmode EQ CHLD_MOD_HldActAndAcpt OR
2090 pCCCmdPrm -> CHLDmode EQ CHLD_MOD_HldActDial) AND
2091 pCCCmdPrm -> mltyCncFlg )
2092 {
2093 process_CHLDaddInfo( srcBuf, CALL_HELD );
2094 }
2095
2096 if( pCCCmdPrm -> mltyCncFlg EQ 0 AND
2097 pCCCmdPrm -> mltyDscFlg EQ 0 ) /* if last call */
2098 {
2099 #ifdef SIM_TOOLKIT
2100 if (ctb->SATinv )
2101 {
2102 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_OK,
2103 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1), BS_SPEED_NotPresent,CME_ERR_NotPresent );
2104
2105 cmhSAT_StartPendingCall( );
2106 }
2107 else
2108 #endif /* SIM_TOOLKIT */
2109 {
2110 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf );
2111
2112 /* log result */
2113 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_OK,
2114 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1), BS_SPEED_NotPresent,CME_ERR_NotPresent);
2115 }
2116 }
2117 }
2118 break;
2119
2120 default: /* no positive result, i.e. negative result of Hold operation */
2121
2122 if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyCncFlg)))
2123 {
2124
2125 #ifdef SIM_TOOLKIT
2126 if (ctb->SATinv)
2127 {
2128 psaCC_ctb(ccShrdPrm.cIdMPTY)->SATinv = FALSE;
2129 /* return network error cause GSM 11.14 / 12.12.3 */
2130 cmhSAT_NtwErr( ADD_NO_CAUSE );
2131 }
2132 #endif
2133 if( pCCCmdPrm -> CHLDmode EQ CHLD_MOD_HldActDial AND
2134 pCCCmdPrm -> mltyCncFlg )
2135 {
2136 for( addId = 0; !((pCCCmdPrm -> mltyCncFlg >> addId) & 0x01); addId++ )
2137 ;
2138
2139 if( CHLDaddInfo EQ CHLD_ADD_INFO_DIAL_CAL )
2140 {
2141 CHLDaddInfo = NO_CHLD_ADD_INFO;
2142 psaCC_FreeCtbNtry (addId);
2143 }
2144 }
2145
2146 pCCCmdPrm -> mltyCncFlg = 0; /* unflag calls */
2147 CHLDaddInfo = NO_CHLD_ADD_INFO;
2148
2149 R_AT( RAT_CME, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf, CME_ERR_OpNotAllow );
2150
2151 /* log result */
2152 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_CME,
2153 (T_ACI_AT_CMD)cmdBuf, -1, BS_SPEED_NotPresent, CME_ERR_OpNotAllow );
2154 }
2155 break;
2156 }
2157 }
2158
2159 /*
2160 +-------------------------------------------------------------------+
2161 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
2162 | ROUTINE : psaCC_CallRetrieved |
2163 +-------------------------------------------------------------------+
2164
2165 PURPOSE : call retrieve result
2166
2167 */
2168
2169 GLOBAL void cmhCC_CallRetrieved ( SHORT cId )
2170 {
2171 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
2172 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
2173 UBYTE cmdBuf; /* buffers current command */
2174 UBYTE srcBuf; /* buffers current command source */
2175
2176 TRACE_FUNCTION ("cmhCC_CallRetrieved()");
2177
2178 /* check for command context */
2179 if (ctb->curCmd NEQ AT_CMD_CHLD)
2180 {
2181 return;
2182 }
2183
2184 pCCCmdPrm = &cmhPrm[ctb->curSrc].ccCmdPrm;
2185 cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf);
2186
2187 /*
2188 * check result of retrieve request
2189 */
2190 switch (ctb->rslt)
2191 {
2192 case( MNCC_CAUSE_RETRIEVE_SUCCESS ):
2193 /* Implements Measure 184, 185 and 187 */
2194 cmhCC_tstAndUnflag_MPTYCall( cId, srcBuf, cmdBuf, pCCCmdPrm );
2195 break;
2196
2197 default: /* no positive result of retrieve operation */
2198
2199 if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyCncFlg)))
2200 {
2201 pCCCmdPrm -> mltyCncFlg = 0; /* unflag calls */
2202
2203 R_AT( RAT_CME, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf, CME_ERR_OpNotAllow );
2204
2205 /* log result */
2206 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_CME,
2207 (T_ACI_AT_CMD)cmdBuf, -1, BS_SPEED_NotPresent, CME_ERR_OpNotAllow );
2208 }
2209 break;
2210 }
2211 }
2212
2213 /*
2214 +-------------------------------------------------------------------+
2215 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
2216 | ROUTINE : cmhCC_RA_Activated |
2217 +-------------------------------------------------------------------+
2218
2219 PURPOSE : RA entity activated, data path established
2220
2221 */
2222 #ifdef DTI
2223 GLOBAL void cmhCC_RA_Activated ( SHORT cId )
2224 {
2225 #ifdef FAX_AND_DATA
2226
2227 UBYTE cmdBuf; /* buffers current command */
2228 UBYTE srcBuf; /* buffers current command source */
2229 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
2230
2231 TRACE_FUNCTION ("cmhCC_RA_Activated()");
2232
2233 srcBuf = psaCC_ctb(cId)->curSrc;
2234 cmdBuf = psaCC_ctb(cId)->curCmd;
2235
2236 switch( ccShrdPrm.datStat )
2237 {
2238 case( DS_ACT_REQ ):
2239 case( DS_REST_REQ ):
2240 switch( calltype )
2241 {
2242 /* transparent data call */
2243 case( TRANS_CALL ):
2244 psaTRA_Activate( );
2245 break;
2246
2247 /* non-transparent data call */
2248 case( NON_TRANS_CALL ):
2249 /* a WAP call is a non-transparent data call */
2250 #ifdef CO_UDP_IP
2251 case( UDPIP_CALL ):
2252 #endif /* CO_UDP_IP */
2253 #ifdef FF_PPP
2254 case( PPP_CALL ):
2255 #endif /* FF_PPP */
2256 #if defined(FF_GPF_TCPIP)
2257 case (TCPIP_CALL):
2258 #endif /* FF_GPF_TCPIP */
2259
2260 if( cmhL2R_Activate((T_ACI_CMD_SRC)srcBuf, (T_ACI_AT_CMD)cmdBuf, cId) NEQ AT_EXCT )
2261 {
2262 ccShrdPrm.datStat = DS_DSC_REQ;
2263 cmhRA_Deactivate ();
2264 }
2265 break;
2266
2267 #ifdef FF_FAX
2268 case( FAX_CALL ):
2269 if( cmhT30_Activate((T_ACI_CMD_SRC)srcBuf, (T_ACI_AT_CMD)cmdBuf, cId) NEQ AT_EXCT )
2270 {
2271 ccShrdPrm.datStat = DS_DSC_REQ;
2272 cmhRA_Deactivate ();
2273 }
2274 break;
2275 #endif /* FF_FAX */
2276
2277 /* in case of other types of call */
2278 default:
2279 ccShrdPrm.datStat = DS_DSC_REQ;
2280 cmhRA_Deactivate ();
2281 break;
2282 }
2283 break;
2284 }
2285 #endif /* of #ifdef FAX_AND_DATA */
2286 }
2287 #endif /* DTI */
2288 /*
2289 +-------------------------------------------------------------------+
2290 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
2291 | ROUTINE : cmhCC_RA_Deactivated |
2292 +-------------------------------------------------------------------+
2293
2294 PURPOSE : RA entity deactivated, data path disconnected
2295
2296 */
2297 #ifdef DTI
2298 GLOBAL void cmhCC_RA_Deactivated ( SHORT cId )
2299 {
2300 #ifdef FAX_AND_DATA
2301 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
2302 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
2303 UBYTE cmdBuf; /* buffers current command */
2304
2305 TRACE_FUNCTION ("cmhCC_RA_Deactivated()");
2306
2307 cmdBuf = ctb->curCmd;
2308
2309 switch( calltype )
2310 {
2311 case( TRANS_CALL ):
2312 /* transparent data call */
2313 switch( ccShrdPrm.datStat )
2314 {
2315 case( DS_ACT ):
2316 case( DS_ACT_REQ ):
2317 case( DS_DSC_REQ ):
2318 case( DS_TCH_MDF ):
2319
2320 ccShrdPrm.datStat = DS_IDL;
2321 ctb->nrmCs = MNCC_CAUSE_CALL_CLEAR;
2322 psaCC_ClearCall (cId);
2323 #if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
2324 /* check impact for SAT commands */
2325 cmhSAT_OpChnCSDDown( cId, TPL_NONE );
2326 #endif /* SIM TOOLKIT AND FF_SAT_E */
2327 break;
2328
2329 case( DS_MDF_REQ ):
2330
2331 ccShrdPrm.datStat = DS_IDL;
2332 psaCC_ModifyCall(cId);
2333 break;
2334
2335 case( DS_STOP_REQ ):
2336
2337 ccShrdPrm.datStat = DS_IDL;
2338 cmhCC_CallDisconnected(cId);
2339 break;
2340 }
2341 break;
2342
2343 /* non-transparent data call */
2344 case( NON_TRANS_CALL ):
2345 #ifdef CO_UDP_IP
2346 case( UDPIP_CALL ):
2347 #endif /* CO_UDP_IP */
2348 #ifdef FF_PPP
2349 case( PPP_CALL ):
2350 #endif /* FF_PPP */
2351 #ifdef FF_GPF_TCPIP
2352 case (TCPIP_CALL):
2353 #endif /* FF_GPF_TCPIP */
2354
2355 switch( ccShrdPrm.datStat )
2356 {
2357 case( DS_ACT ):
2358 case( DS_ACT_REQ ):
2359 case( DS_DSC_REQ ):
2360 case( DS_REST_REQ ):
2361 case( DS_TCH_MDF ):
2362
2363 ccShrdPrm.datStat = DS_IDL;
2364 ctb->nrmCs = MNCC_CAUSE_CALL_CLEAR;
2365
2366 #if defined(CO_UDP_IP) OR defined(FF_GPF_TCPIP)
2367 /* WAP STACK is down */
2368
2369 /* The following statements check which configuration is active,
2370 because there are three possibilities:
2371 1. UDP/IP only - WAP1.x and SAT_E
2372 2. TCP/IP only - WAP2.x and higher and App's
2373 3. UDP/IP and TCP/IP - WAP2.x and higher and App's and SAT_E
2374 */
2375 #if defined(FF_GPF_TCPIP) AND !defined(CO_UDP_IP)
2376 if(calltype EQ TCPIP_CALL)
2377 #elif !defined(FF_GPF_TCPIP) AND defined(CO_UDP_IP)
2378 if(calltype EQ UDPIP_CALL)
2379 #elif defined(FF_GPF_TCPIP) AND defined(CO_UDP_IP)
2380 if(calltype EQ UDPIP_CALL OR calltype EQ TCPIP_CALL)
2381 #endif
2382 {
2383 #if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
2384 /* check impact for SAT commands */
2385 cmhSAT_OpChnCSDDown( cId, UDP );
2386 #endif /* SIM TOOLKIT AND FF_SAT_E */
2387 /* Have CC disconnected before ? */
2388 if (ctb->calStat EQ CS_ACT)
2389 {
2390 psaCC_ClearCall (cId);
2391 }
2392 else
2393 {
2394 /* Message to MMI */
2395 R_AT( RAT_OK, (T_ACI_CMD_SRC)ctb->calOwn ) ( AT_CMD_NONE, cId+1 );
2396
2397 #ifdef FF_ATI
2398 io_setDCD ((T_ACI_CMD_SRC)ctb->calOwn, IO_DCD_OFF); /* V.24 DCD Line */
2399 #endif
2400 /* log result */
2401 cmh_logRslt ((T_ACI_CMD_SRC)ctb->calOwn, RAT_OK,
2402 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1), BS_SPEED_NotPresent,CME_ERR_NotPresent );
2403 }
2404 break;
2405 }
2406 #endif /* CO_UDP_IP || FF_GPF_TCPIP */
2407
2408 psaCC_ClearCall (cId);
2409 #if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
2410 /* check impact for SAT commands */
2411 cmhSAT_OpChnCSDDown( cId, TPL_NONE );
2412 #endif /* SIM TOOLKIT AND FF_SAT_E */
2413 break;
2414
2415 case( DS_STOP_REQ ):
2416
2417 ccShrdPrm.datStat = DS_IDL;
2418 cmhCC_CallDisconnected(cId);
2419 #if defined (FF_WAP) || defined (FF_SAT_E)
2420 /* WAP STACK is down */
2421 ccShrdPrm.wapStat = CC_WAP_STACK_DOWN;
2422 #endif /* FF_WAP || SAT E */
2423 break;
2424
2425 case( DS_ABO_REQ ): /* during modification */
2426 switch( ctb->rptInd )
2427 {
2428 case( MNCC_RI_SEQUENTIAL ): /* no way back */
2429
2430 ccShrdPrm.datStat = DS_IDL;
2431 ctb->nrmCs = MNCC_CAUSE_CALL_CLEAR;
2432 psaCC_ClearCall (cId);
2433 break;
2434
2435 case( MNCC_RI_CIRCULAR ):
2436
2437 ccShrdPrm.datStat = DS_IDL;
2438 psaCC_ModifyCall(cId); /* back to former service */
2439 break;
2440 }
2441 break;
2442
2443 case( DS_MDF_REQ ):
2444 ccShrdPrm.datStat = DS_IDL;
2445 psaCC_ModifyCall(cId);
2446 break;
2447 }
2448 break;
2449
2450 /* in case of a fax call */
2451 case( FAX_CALL ):
2452 switch( ccShrdPrm.datStat )
2453 {
2454 case( DS_ACT ):
2455 case( DS_ACT_REQ ):
2456 case( DS_DSC_REQ ):
2457 case( DS_REST_REQ ):
2458 case( DS_TCH_MDF ):
2459 ccShrdPrm.datStat = DS_IDL;
2460 ctb->nrmCs = MNCC_CAUSE_CALL_CLEAR;
2461 psaCC_ClearCall (cId);
2462 break;
2463
2464 case( DS_STOP_REQ ):
2465 ccShrdPrm.datStat = DS_IDL;
2466 cmhCC_CallDisconnected(cId);
2467 break;
2468
2469 case( DS_ABO_REQ ): /* abort during modification */
2470 switch (ctb->rptInd)
2471 {
2472 case( MNCC_RI_SEQUENTIAL ): /* no way back */
2473
2474 ccShrdPrm.datStat = DS_IDL;
2475 ctb->nrmCs = MNCC_CAUSE_CALL_CLEAR;
2476 psaCC_ClearCall (cId);
2477 break;
2478
2479 case( MNCC_RI_CIRCULAR ):
2480
2481 ccShrdPrm.datStat = DS_IDL;
2482 psaCC_ModifyCall(cId); /* back to former service */
2483 break;
2484 }
2485 break;
2486
2487 case( DS_MDF_REQ ):
2488 ccShrdPrm.datStat = DS_IDL;
2489 psaCC_ModifyCall(cId);
2490 break;
2491 }
2492 break;
2493 }
2494 #endif /* of #ifdef FAX_AND_DATA */
2495 }
2496 #endif /* DTI */
2497
2498 #ifdef FF_FAX
2499 /*
2500 +-------------------------------------------------------------------+
2501 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
2502 | ROUTINE : cmhCC_RA_Modified |
2503 +-------------------------------------------------------------------+
2504
2505 PURPOSE : RA entity modified after CMM
2506
2507 */
2508 #ifdef DTI
2509 GLOBAL void cmhCC_RA_Modified ( SHORT cId )
2510 {
2511 #ifdef FAX_AND_DATA
2512
2513 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
2514
2515 TRACE_FUNCTION ("cmhCC_RA_Modified()");
2516
2517 if( calltype EQ FAX_CALL )
2518 {
2519 /* only in case of a fax call */
2520 if( ccShrdPrm.datStat EQ DS_TCH_MDF )
2521 {
2522 ccShrdPrm.datStat = DS_ACT;
2523
2524 if( cmhT30_Modify() NEQ AT_EXCT )
2525 {
2526 ccShrdPrm.datStat = DS_DSC_REQ;
2527 cmhRA_Deactivate ();
2528 }
2529 }
2530 }
2531 #endif /* of #ifdef FAX_AND_DATA */
2532 }
2533 #endif /* DTI */
2534 #endif /* FF_FAX */
2535
2536 /*
2537 +-------------------------------------------------------------------+
2538 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
2539 | ROUTINE : cmhCC_L2R_or_TRA_Activated |
2540 +-------------------------------------------------------------------+
2541
2542 PURPOSE : L2R entity activated, data path established
2543
2544 */
2545 #ifdef DTI
2546 GLOBAL void cmhCC_L2R_or_TRA_Activated ( T_DTI_ENTITY_ID activated_module, SHORT cId )
2547 {
2548 #ifdef FAX_AND_DATA
2549 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
2550 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
2551 UBYTE cmdBuf; /* buffers current command */
2552 UBYTE srcBuf; /* buffers current command source */
2553 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
2554
2555 TRACE_FUNCTION ("cmhCC_L2R_or_TRA_Activated()");
2556
2557 if (!psaCC_ctbIsValid (cId))
2558 {
2559 /*
2560 * If for some no good reason we got a L2R_CONNECT_CNF, L2R_CONNECT_IND
2561 * or TRA_ACTIVATE_CNF without having a valid entry in the call table,
2562 * we do here the same as for the FAX case where those events are also
2563 * unexpected. We send the respective deativation request.
2564 */
2565 TRACE_ERROR ("Call table entry disappeared");
2566 ccShrdPrm.datStat = DS_DSC_REQ;
2567 switch( activated_module )
2568 {
2569 case( DTI_ENTITY_TRA ):
2570 psaTRA_Deactivate();
2571 break;
2572 case( DTI_ENTITY_L2R ):
2573 cmhL2R_Deactivate();
2574 break;
2575 default: /* Unexpected to happen */
2576 break;
2577 }
2578 return;
2579 }
2580
2581 cmdBuf = ctb->curCmd;
2582 srcBuf = ctb->curSrc;
2583 pCCCmdPrm = &cmhPrm[srcBuf].ccCmdPrm;
2584
2585 switch( calltype )
2586 {
2587 case( TRANS_CALL ):
2588 case( NON_TRANS_CALL ):
2589
2590 #ifdef CO_UDP_IP
2591 case( UDPIP_CALL ):
2592 #endif /* CO_UDP_IP */
2593 #ifdef FF_PPP
2594 case( PPP_CALL ):
2595 #endif /* FF_PPP */
2596 #if defined(FF_GPF_TCPIP)
2597 case (TCPIP_CALL):
2598 #endif /* FF_GPF_TCPIP */
2599
2600 switch( ccShrdPrm.datStat )
2601 {
2602 case( DS_ACT_REQ ):
2603
2604 ccShrdPrm.datStat = DS_ACT;
2605 cmhCC_PrepareCmdEnd (cId, NULL, NULL);
2606
2607 /* reset CMOD to single mode */
2608 ccShrdPrm.CMODmode = CMOD_MOD_Single;
2609
2610 /* check if connect is expected */
2611 if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyCncFlg)))
2612 {
2613 if( pCCCmdPrm -> mltyCncFlg EQ 0 ) /* if last call */
2614 {
2615 R_AT( RAT_CR, (T_ACI_CMD_SRC)srcBuf )
2616 (cmhCC_GetSrvType (&ctb->BC[ctb->curBC]));
2617
2618 R_AT( RAT_ILRR, (T_ACI_CMD_SRC)srcBuf )
2619 (cmhCC_GetDataRate (&ctb->BC[ctb->curBC]),
2620 cmhCC_GetFormat (&ctb->BC[ctb->curBC]),
2621 cmhCC_GetParity (&ctb->BC[ctb->curBC]));
2622 #if defined (CO_UDP_IP) AND defined (FF_GPF_TCPIP)
2623 if ( (calltype NEQ UDPIP_CALL) AND (calltype NEQ TCPIP_CALL) )
2624 #endif
2625 #if defined (CO_UDP_IP) AND !defined(FF_GPF_TCPIP)
2626 if (calltype NEQ UDPIP_CALL)
2627 #endif
2628 #if defined (FF_GPF_TCPIP) AND !defined(CO_UDP_IP)
2629 if (calltype NEQ TCPIP_CALL)
2630 #endif
2631 #ifdef FF_PPP
2632 if (calltype NEQ PPP_CALL)
2633 #endif /* FF_PPP */
2634 {
2635 #if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
2636 if (!cmhSAT_OpChnChckCSD( TPL_NONE))
2637 #endif /* of SIM_TOOLKIT AND FF_SAT_E*/
2638 {
2639 R_AT( RAT_CONNECT, (T_ACI_CMD_SRC)srcBuf )
2640 (cmdBuf, cmhCC_GetDataRate(&ctb->BC[ctb->curBC]), cId+1, FALSE);
2641 }
2642 }
2643
2644 /* log result */
2645 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_CONNECT,
2646 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1),
2647 (T_ACI_BS_SPEED)cmhCC_GetDataRate(&ctb->BC[ctb->curBC]), CME_ERR_NotPresent );
2648
2649 switch( activated_module )
2650 {
2651 case( DTI_ENTITY_TRA ):
2652 if (IS_SRC_BT(srcBuf))
2653 {
2654 T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_BLUETOOTH, DTI_ENTITY_TRA};
2655 UBYTE dti_id = dti_cntrl_new_dti(DTI_DTI_ID_NOTPRESENT);
2656 dti_cntrl_est_dpath ( dti_id,
2657 entity_list,
2658 2,
2659 SPLIT,
2660 TRA_connect_dti_cb);
2661 }
2662 #if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
2663 if (cmhSAT_OpChnChckCSD( TPL_NONE))
2664 {
2665 cmhSAT_OpChnSIMCnctReq( DTI_ENTITY_TRA );
2666 }
2667 #endif /* of SIM_TOOLKIT AND FF_SAT_E */
2668 else
2669 {
2670 T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_TRA};
2671
2672 dti_cntrl_est_dpath_indirect ( srcBuf,
2673 entity_list,
2674 1,
2675 SPLIT,
2676 TRA_connect_dti_cb,
2677 DTI_CPBLTY_SER,
2678 DTI_CID_NOTPRESENT);
2679 }
2680 break;
2681
2682 case( DTI_ENTITY_L2R ):
2683 #ifdef CO_UDP_IP
2684 if ( calltype EQ UDPIP_CALL )
2685 {
2686 UBYTE dti_id;
2687 T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_IP, DTI_ENTITY_PPPC, DTI_ENTITY_L2R};
2688 #if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
2689 if ( satShrdPrm.opchStat EQ OPCH_EST_REQ )
2690 dti_id = simShrdPrm.sat_class_e_dti_id;
2691 else
2692 #endif /* SIM_TOOLKIT AND FF_SAT_E */
2693 dti_id = wap_dti_id;
2694
2695 dti_cntrl_est_dpath ( dti_id,
2696 entity_list,
2697 3,
2698 APPEND,
2699 IP_UDP_connect_dti_cb);
2700 break;
2701 }
2702 #endif /* CO_UDP_IP */
2703
2704 #if defined (FF_PPP) AND defined (DTI)
2705 if ( calltype EQ PPP_CALL )
2706 {
2707 T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_PPPC, DTI_ENTITY_L2R};
2708 dti_cntrl_est_dpath_indirect ( srcBuf,
2709 entity_list,
2710 2,
2711 SPLIT,
2712 L2R_connect_dti_cb,
2713 DTI_CPBLTY_PKT,
2714 DTI_CID_NOTPRESENT);
2715 break;
2716 }
2717 #endif /* FF_PPP */
2718
2719 #ifdef FF_GPF_TCPIP
2720 if ( calltype EQ TCPIP_CALL )
2721 {
2722 UBYTE dti_id;
2723 T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_TCPIP, DTI_ENTITY_PPPC, DTI_ENTITY_L2R};
2724 /* create a WAP DTI if not present */
2725 if (wap_dti_id EQ DTI_DTI_ID_NOTPRESENT)
2726 {
2727 wap_dti_id = dti_cntrl_new_dti (DTI_DTI_ID_NOTPRESENT);
2728 TRACE_EVENT_P1("tcpip_wap_dti_id = %d", wap_dti_id);
2729 }
2730 dti_id = wap_dti_id;
2731 dti_cntrl_est_dpath ( dti_id,
2732 entity_list,
2733 3,
2734 SPLIT,
2735 TCPIP_connect_dti_cb);
2736 break;
2737 }
2738 #endif /* FF_GPF_TCPIP */
2739
2740 #if defined (SIM_TOOLKIT) AND defined (FF_SAT_E)
2741 if (cmhSAT_OpChnChckCSD( TPL_NONE))
2742 {
2743 cmhSAT_OpChnSIMCnctReq( DTI_ENTITY_L2R );
2744 }
2745 #endif /* of SIM_TOOLKIT AND FF_SAT_E */
2746
2747 #ifdef DTI
2748 if (IS_SRC_BT(srcBuf))
2749 {
2750 T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_BLUETOOTH, DTI_ENTITY_L2R};
2751 UBYTE dti_id = dti_cntrl_new_dti(DTI_DTI_ID_NOTPRESENT);
2752 dti_cntrl_est_dpath ( dti_id,
2753 entity_list,
2754 2,
2755 SPLIT,
2756 L2R_connect_dti_cb);
2757 }
2758 else
2759 {
2760 T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_L2R};
2761 dti_cntrl_est_dpath_indirect ( srcBuf,
2762 entity_list,
2763 1,
2764 SPLIT,
2765 L2R_connect_dti_cb,
2766 DTI_CPBLTY_SER,
2767 DTI_CID_NOTPRESENT);
2768 }
2769 #endif /* DTI */
2770 break;
2771 } /* switch( activated_module ) */
2772 } /* if( pCCCmdPrm -> mltyCncFlg EQ 0 ) */
2773 } /* if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyCncFlg))) */
2774 break;
2775
2776 case( DS_REST_REQ ):
2777 ccShrdPrm.datStat = DS_ACT;
2778 break;
2779 }
2780 break;
2781 /* in case of a fax call */
2782 case( FAX_CALL ):
2783
2784 TRACE_EVENT( "UNEXP BEARER SERV FAX" );
2785 ccShrdPrm.datStat = DS_DSC_REQ;
2786 switch( activated_module )
2787 {
2788 case( DTI_ENTITY_TRA ):
2789 psaTRA_Deactivate();
2790 break;
2791 case( DTI_ENTITY_L2R ):
2792 cmhL2R_Deactivate();
2793 break;
2794 }
2795 break;
2796 }
2797 #endif /* of #ifdef FAX_AND_DATA */
2798 }
2799 #endif /* UART */
2800
2801 /*
2802 +-------------------------------------------------------------------+
2803 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
2804 | ROUTINE : cmhCC_L2R_or_TRA_Deactivated |
2805 +-------------------------------------------------------------------+
2806
2807 PURPOSE : L2R entity deactivated, data path disconnected
2808
2809 */
2810 #ifdef UART
2811 GLOBAL void cmhCC_L2R_or_TRA_Deactivated ( SHORT cId )
2812 {
2813 #ifdef FAX_AND_DATA
2814
2815 UBYTE srcBuf;
2816 #ifdef DTI
2817 T_DTI_CNTRL dti_cntrl_info;
2818 #endif /* DTI */
2819 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
2820
2821 /* if there is a redirection get proper source */
2822 #ifdef DTI
2823 if (dti_cntrl_get_info_from_dti_id(raShrdPrm.dti_id, &dti_cntrl_info))
2824 {
2825 srcBuf = dti_cntrl_info.src_id;
2826 }
2827 else /* if it is not a valid dti_id - take stored src_id */
2828 {
2829 TRACE_EVENT_P2("No valid dti_id:%d taking owner:%d",
2830 raShrdPrm.dti_id,
2831 raShrdPrm.owner);
2832 #endif /* DTI */
2833 srcBuf = raShrdPrm.owner;
2834 #ifdef DTI
2835 }
2836 /* reset ra dti_id storage */
2837 raShrdPrm.dti_id = NOT_PRESENT_8BIT;
2838 #endif /* DTI */
2839
2840 TRACE_FUNCTION ("cmhCC_L2R_or_TRA_Deactivated()");
2841
2842 io_setDCD ((T_ACI_CMD_SRC)srcBuf, IO_DCD_OFF);
2843
2844 switch( calltype )
2845 {
2846 case( TRANS_CALL ):
2847 case( NON_TRANS_CALL ):
2848
2849 #ifdef CO_UDP_IP
2850 case( UDPIP_CALL ):
2851 #endif /* CO_UDP_IP */
2852 #ifdef FF_PPP
2853 case( PPP_CALL ):
2854 #endif /* FF_PPP */
2855 #if defined(FF_GPF_TCPIP)
2856 case (TCPIP_CALL):
2857 #endif /* FF_GPF_TCPIP */
2858
2859 switch( ccShrdPrm.datStat )
2860 {
2861 case( DS_ACT ):
2862 case( DS_ACT_REQ ):
2863 case( DS_DSC_REQ ):
2864 case( DS_MDF_REQ ):
2865 case( DS_STOP_REQ ):
2866
2867 cmhRA_Deactivate ();
2868 break;
2869 }
2870 break;
2871
2872 case( FAX_CALL ):
2873 TRACE_EVENT( "UNEXP BEARER SERV FAX" );
2874 ccShrdPrm.datStat = DS_DSC_REQ;
2875 cmhRA_Deactivate();
2876 break;
2877 }
2878 #endif /* of #ifdef FAX_AND_DATA */
2879 }
2880 #endif /* UART */
2881
2882 /*
2883 +-------------------------------------------------------------------+
2884 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
2885 | ROUTINE : cmhCC_L2R_Failed |
2886 +-------------------------------------------------------------------+
2887
2888 PURPOSE : L2R entity failure
2889
2890 */
2891
2892 GLOBAL void cmhCC_L2R_Failed ( void )
2893 {
2894 #ifdef FAX_AND_DATA
2895 SHORT cId = raShrdPrm.cId; /* holds call identifier */
2896 T_CC_CALL_TYPE calltype;
2897
2898 TRACE_FUNCTION ("cmhCC_L2R_Failed()");
2899
2900 calltype = cmhCC_getcalltype(cId);
2901
2902 switch( calltype )
2903 {
2904 case( NON_TRANS_CALL ):
2905 switch( ccShrdPrm.datStat )
2906 {
2907 case( DS_ACT_REQ ):
2908 if( psaCC_ctbIsValid (cId) AND
2909 psaCC_ctb(cId)->calStat EQ CS_MDF_REQ )
2910 {
2911 ccShrdPrm.datStat = DS_ABO_REQ;
2912 }
2913 /*lint -fallthrough*/
2914 case( DS_ACT ):
2915 case( DS_REST_REQ ):
2916 cmhL2R_Deactivate ();
2917 break;
2918 }
2919 break;
2920
2921
2922 case( FAX_CALL ):
2923
2924 TRACE_EVENT( "UNEXP BEARER SERV FAX" );
2925 ccShrdPrm.datStat = DS_DSC_REQ;
2926 cmhL2R_Deactivate();
2927 break;
2928 }
2929
2930 #endif /* of #ifdef FAX_AND_DATA */
2931 }
2932
2933 #ifdef FF_FAX
2934 /*
2935 +-------------------------------------------------------------------+
2936 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
2937 | ROUTINE : cmhCC_T30_Activated |
2938 +-------------------------------------------------------------------+
2939
2940 PURPOSE : T30 entity activated, data path established
2941
2942 */
2943
2944 GLOBAL void cmhCC_T30_Activated ( void )
2945 {
2946 #if defined (FAX_AND_DATA) AND defined (DTI)
2947
2948 SHORT cId = t30ShrdPrm.cId; /* holds call identifier */
2949 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
2950
2951 TRACE_FUNCTION ("cmhCC_T30_Activated()");
2952
2953 (void)&cmhPrm[psaCC_ctb(cId)->calOwn].ccCmdPrm;
2954 (void)psaCC_ctb(cId)->curCmd;
2955
2956 switch( calltype )
2957 {
2958 case( FAX_CALL ):
2959 switch( ccShrdPrm.datStat )
2960 {
2961 case( DS_ACT_REQ ):
2962
2963 ccShrdPrm.datStat = DS_ACT;
2964
2965 /* reset CMOD to single mode */
2966 ccShrdPrm.CMODmode = CMOD_MOD_Single;
2967
2968 if( psaCC_ctb(cId)->calType EQ CT_MTC )
2969 {
2970 cmhT30_SendCaps( (T_ACI_CMD_SRC)psaCC_ctb(cId)->curSrc, FRT_DIS );
2971 }
2972 break;
2973 }
2974 break;
2975
2976 /* in case of a asynchronous call */
2977 case( TRANS_CALL ):
2978 case( NON_TRANS_CALL ):
2979 TRACE_EVENT( "UNEXP BEARER SERV ASYNC" );
2980 ccShrdPrm.datStat = DS_DSC_REQ;
2981 cmhT30_Deactivate();
2982 break;
2983 }
2984
2985 #endif /* of #ifdef FAX_AND_DATA */
2986 }
2987
2988 /*
2989 +-------------------------------------------------------------------+
2990 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
2991 | ROUTINE : cmhCC_T30_Deactivated |
2992 +-------------------------------------------------------------------+
2993
2994 PURPOSE : T30 entity deactivated, data path disconnected
2995
2996 */
2997
2998 GLOBAL void cmhCC_T30_Deactivated ( void )
2999 {
3000 #ifdef FAX_AND_DATA
3001
3002 SHORT cId = t30ShrdPrm.cId; /* holds call identifier */
3003 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
3004
3005 TRACE_FUNCTION ("cmhCC_T30_Deactivated()");
3006
3007 switch( calltype )
3008 {
3009 case( FAX_CALL ):
3010 switch( ccShrdPrm.datStat )
3011 {
3012 case( DS_ACT ):
3013 case( DS_ACT_REQ ):
3014 case( DS_DSC_REQ ):
3015 case( DS_MDF_REQ ):
3016 case( DS_STOP_REQ ):
3017 case( DS_TCH_MDF ):
3018
3019 cmhRA_Deactivate ();
3020 break;
3021 }
3022 break;
3023
3024 /* in case of a asynchronous data call */
3025 case( TRANS_CALL ):
3026 case( NON_TRANS_CALL ):
3027
3028 TRACE_EVENT( "UNEXP BEARER SERV ASYNC" );
3029 ccShrdPrm.datStat = DS_DSC_REQ;
3030 cmhRA_Deactivate();
3031 break;
3032 }
3033
3034 #endif /* of #ifdef FAX_AND_DATA */
3035 }
3036
3037 /*
3038 +-------------------------------------------------------------------+
3039 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
3040 | ROUTINE : cmhCC_T30_Failed |
3041 +-------------------------------------------------------------------+
3042
3043 PURPOSE : T30 entity failure
3044
3045 */
3046
3047 GLOBAL void cmhCC_T30_Failed ( void )
3048 {
3049 #if defined FAX_AND_DATA AND defined (DTI)
3050
3051 SHORT cId = t30ShrdPrm.cId; /* holds call identifier */
3052 T_CC_CALL_TYPE calltype = cmhCC_getcalltype(cId);
3053
3054 TRACE_FUNCTION ("cmhCC_T30_Failed()");
3055
3056 switch( calltype )
3057 {
3058 case( FAX_CALL ):
3059
3060 switch( ccShrdPrm.datStat )
3061 {
3062 case( DS_ACT_REQ ):
3063
3064 if( psaCC_ctb(cId)->calStat EQ CS_MDF_REQ )
3065 {
3066 ccShrdPrm.datStat = DS_ABO_REQ;
3067 }
3068 /*lint -fallthrough*/
3069 case( DS_ACT ):
3070 case( DS_REST_REQ ):
3071 case( DS_TCH_MDF ):
3072
3073 cmhT30_Deactivate ();
3074 break;
3075 }
3076 break;
3077
3078 /* in case of a asynchronous data call */
3079 case( TRANS_CALL ):
3080 case( NON_TRANS_CALL ):
3081
3082 TRACE_EVENT( "UNEXP BEARER SERV ASYNC" );
3083 ccShrdPrm.datStat = DS_DSC_REQ;
3084 cmhT30_Deactivate();
3085 break;
3086 }
3087
3088 #endif /* of #ifdef FAX_AND_DATA */
3089 }
3090
3091 /*
3092 +-------------------------------------------------------------------+
3093 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
3094 | ROUTINE : cmhCC_T30_RmtCaps |
3095 +-------------------------------------------------------------------+
3096
3097 PURPOSE : T30 remote capability indication
3098
3099 */
3100
3101 GLOBAL void cmhCC_T30_RmtCaps ( void )
3102 {
3103 #ifdef FAX_AND_DATA
3104
3105 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
3106 UBYTE cmdBuf; /* buffers current command */
3107 UBYTE srcBuf; /* buffers current command source */
3108 SHORT cId = t30ShrdPrm.cId; /* holds call identifier */
3109
3110 TRACE_FUNCTION ("cmhCC_T30_RmtCaps()");
3111
3112 /*
3113 *-------------------------------------------------------------------
3114 * check if connect is expected
3115 *-------------------------------------------------------------------
3116 */
3117 pCCCmdPrm = &cmhPrm[psaCC_ctb(cId)->curSrc].ccCmdPrm;
3118 cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf);
3119
3120 if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyCncFlg)))
3121 {
3122 if( pCCCmdPrm -> mltyCncFlg EQ 0 ) /* if last call */
3123 {
3124 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf );
3125
3126 /* log result */
3127 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_OK,
3128 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1), BS_SPEED_NotPresent,CME_ERR_NotPresent);
3129 }
3130 }
3131
3132 #endif /* of #ifdef FAX_AND_DATA */
3133 }
3134
3135 #endif /* FF_FAX */
3136 /*
3137 +-------------------------------------------------------------------+
3138 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
3139 | ROUTINE : cmhCC_MPTYBuild |
3140 +-------------------------------------------------------------------+
3141
3142 PURPOSE : Multiparty successful build.
3143
3144 */
3145
3146 GLOBAL void cmhCC_MPTYBuild( SHORT cId,
3147 T_BUILD_MPTY_RES *bldMPTY )
3148 {
3149 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
3150 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
3151 UBYTE ctbIdx; /* holds call table index */
3152 UBYTE cmdBuf; /* buffers command */
3153 UBYTE srcBuf; /* buffers command source */
3154
3155 TRACE_FUNCTION ("cmhCC_MPTYBuild()");
3156
3157 TIMERSTOP( ACI_TMPTY );
3158
3159 if( ctb->curCmd NEQ AT_CMD_CHLD )
3160 return; /* wrong command context */
3161
3162 /* set multiparty status for involved calls */
3163 for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
3164 {
3165 if (ccShrdPrm.ctb[ctbIdx] NEQ NULL AND
3166 (psaCC_ctb(ctbIdx)->mptyStat EQ CS_ACT_REQ OR
3167 psaCC_ctb(ctbIdx)->mptyStat EQ CS_ACT ))
3168 {
3169 psaCC_ctb(ctbIdx)->mptyStat = CS_ACT;
3170 psaCC_ctb(ctbIdx)->calStat = CS_ACT;
3171 }
3172 }
3173
3174 pCCCmdPrm = &cmhPrm[ctb->curSrc].ccCmdPrm;
3175 cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf);
3176
3177 psaCC_MPTY (cId, MNCC_MPTY_BUILD_SUCCESS);
3178 /* Implements Measure 184, 185 and 187 */
3179 cmhCC_tstAndUnflag_MPTYCall( cId, srcBuf, cmdBuf, pCCCmdPrm );
3180 }
3181
3182 /*
3183 +-------------------------------------------------------------------+
3184 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
3185 | ROUTINE : cmhCC_MPTYSplit |
3186 +-------------------------------------------------------------------+
3187
3188 PURPOSE : Multiparty successful split.
3189
3190 */
3191
3192 GLOBAL void cmhCC_MPTYSplit( SHORT cId,
3193 T_SPLIT_MPTY_RES *splMPTY )
3194 {
3195 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
3196 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
3197 UBYTE ctbIdx; /* holds call table index */
3198 UBYTE cmdBuf; /* buffers command */
3199 UBYTE srcBuf; /* buffers command source */
3200 UBYTE fndCal; /* holds number of found calls */
3201
3202 TRACE_FUNCTION ("cmhCC_MPTYSplit()");
3203
3204 TIMERSTOP( ACI_TMPTY );
3205
3206 if( ctb->curCmd NEQ AT_CMD_CHLD )
3207 return; /* wrong command context */
3208
3209 /* set status for involved calls */
3210 for( fndCal = 0, ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
3211 {
3212 if( ccShrdPrm.ctb[ctbIdx] NEQ NULL AND
3213 psaCC_ctb(ctbIdx)->mptyStat EQ CS_ACT AND
3214 ctbIdx NEQ cId )
3215 {
3216 psaCC_ctb(ctbIdx)->calStat = CS_HLD;
3217 fndCal++;
3218 }
3219 }
3220
3221 /* if only one other call is left, reset multiparty status */
3222 /* if only one other call is left, do not reset multiparty status - VO patch
3223 if( fndCal EQ 1 )
3224 {
3225 psaCC_ctb(fndCId)->mptyStat = CS_IDL;
3226 }
3227 */
3228
3229 pCCCmdPrm = &cmhPrm[ctb->curSrc].ccCmdPrm;
3230 cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf);
3231 ctb->calStat = CS_ACT;
3232 ctb->mptyStat = CS_IDL;
3233
3234 psaCC_MPTY (cId, MNCC_MPTY_SPLIT_SUCCESS);
3235
3236 psaCC_setSpeechMode (); /* In case we split from a held mpty */
3237 /* Implements Measure 184, 185 and 187 */
3238 cmhCC_tstAndUnflag_MPTYCall( cId, srcBuf, cmdBuf, pCCCmdPrm );
3239 }
3240
3241 /*
3242 +-------------------------------------------------------------------+
3243 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
3244 | ROUTINE : cmhCC_MPTYHeld |
3245 +-------------------------------------------------------------------+
3246
3247 PURPOSE : Multiparty successful held.
3248
3249 */
3250
3251 GLOBAL void cmhCC_MPTYHeld( SHORT cId,
3252 T_HOLD_MPTY_RES *hldMPTY )
3253 {
3254 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
3255 UBYTE ctbIdx; /* holds call table index */
3256 UBYTE cmdBuf; /* buffers command */
3257 UBYTE srcBuf; /* buffers command source */
3258
3259 TRACE_FUNCTION ("cmhCC_MPTYHeld()");
3260
3261 TIMERSTOP( ACI_TMPTY );
3262
3263 /* check for command context */
3264 switch( psaCC_ctb(cId)->curCmd )
3265 {
3266 case( AT_CMD_CHLD ):
3267 case( AT_CMD_D ):
3268 break;
3269
3270 default:
3271 return; /* wrong command context */
3272 }
3273
3274 /* set call status for multiparty call member */
3275 for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
3276 {
3277 if( ccShrdPrm.ctb[ctbIdx] NEQ NULL AND
3278 psaCC_ctb(ctbIdx)->calStat EQ CS_HLD_REQ AND
3279 psaCC_ctb(ctbIdx)->mptyStat EQ CS_ACT )
3280 {
3281 psaCC_ctb(ctbIdx)->calStat = CS_HLD;
3282 }
3283 }
3284
3285 psaCC_MPTY (cId, MNCC_MPTY_HOLD_SUCCESS);
3286
3287 psaCC_setSpeechMode ();
3288
3289 pCCCmdPrm = &cmhPrm[psaCC_ctb(cId)->curSrc].ccCmdPrm;
3290 cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf);
3291
3292 if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyCncFlg)))
3293 {
3294 if((pCCCmdPrm -> CHLDmode EQ CHLD_MOD_HldActExc OR
3295 pCCCmdPrm -> CHLDmode EQ CHLD_MOD_HldActAndAcpt OR
3296 pCCCmdPrm -> CHLDmode EQ CHLD_MOD_HldActDial) AND
3297 pCCCmdPrm -> mltyCncFlg )
3298 {
3299 process_CHLDaddInfo( srcBuf, MTPTY_HELD );
3300 }
3301
3302 if( pCCCmdPrm -> mltyCncFlg EQ 0 AND
3303 pCCCmdPrm -> mltyDscFlg EQ 0 ) /* if last call */
3304 {
3305 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf );
3306
3307 /* log result */
3308 cmh_logRslt ((T_ACI_CMD_SRC)srcBuf, RAT_OK,
3309 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1),BS_SPEED_NotPresent,CME_ERR_NotPresent);
3310 }
3311 }
3312 }
3313
3314 /*
3315 +-------------------------------------------------------------------+
3316 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
3317 | ROUTINE : cmhCC_MPTYRetrieved |
3318 +-------------------------------------------------------------------+
3319
3320 PURPOSE : Multiparty successful retrieved.
3321
3322 */
3323
3324 GLOBAL void cmhCC_MPTYRetrieved( SHORT cId,
3325 T_RETRIEVE_MPTY_RES *rtvMPTY )
3326 {
3327 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
3328 UBYTE ctbIdx; /* holds call table index */
3329 UBYTE cmdBuf; /* buffers command */
3330 UBYTE srcBuf; /* buffers command source */
3331
3332 TRACE_FUNCTION ("cmhCC_MPTYRetrieved()");
3333
3334 TIMERSTOP( ACI_TMPTY );
3335
3336 if( psaCC_ctb(cId)->curCmd NEQ AT_CMD_CHLD )
3337 return; /* wrong command context */
3338
3339 /* set call status for multiparty call member */
3340 for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
3341 {
3342 if( ccShrdPrm.ctb[ctbIdx] NEQ NULL AND
3343 psaCC_ctb(ctbIdx)->calStat EQ CS_ACT_REQ AND
3344 psaCC_ctb(ctbIdx)->mptyStat EQ CS_ACT )
3345 {
3346 psaCC_ctb(ctbIdx)->calStat = CS_ACT;
3347 }
3348 }
3349
3350 pCCCmdPrm = &cmhPrm[psaCC_ctb(cId)->curSrc].ccCmdPrm;
3351 cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf);
3352
3353 psaCC_MPTY (cId, MNCC_MPTY_RETRIEVE_SUCCESS);
3354
3355 psaCC_setSpeechMode ();
3356 /* Implements Measure 184, 185 and 187 */
3357 cmhCC_tstAndUnflag_MPTYCall( cId, srcBuf, cmdBuf, pCCCmdPrm );
3358
3359 }
3360
3361 /*
3362 +-------------------------------------------------------------------+
3363 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
3364 | ROUTINE : cmhCC_NotifySS |
3365 +-------------------------------------------------------------------+
3366
3367 PURPOSE : SS notification received: in preamble, some
3368 local functions, otherwise, the function would be huge...
3369
3370 */
3371
3372 /*
3373 +------------------------------------------------------------------------------
3374 | Function : send_CSSX_notification
3375 +------------------------------------------------------------------------------
3376 | Description : This function sends CSSU and CSSI.
3377 |
3378 | Parameters : ctbIdx - call table index
3379 | cssx_code - CSS(X) code
3380 | index - Index
3381 | *number - buffer for number
3382 | *toa - buffers type of address
3383 | *subaddr - buffer for subaddress
3384 | *tos - holds type of subaddress
3385 |
3386 | Return :
3387 +------------------------------------------------------------------------------
3388 */
3389
3390 GLOBAL void send_CSSX_notification(SHORT ctbIdx,
3391 T_ACI_CSSX_CODE cssx_code,
3392 SHORT index,
3393 CHAR *number,
3394 T_ACI_TOA *toa,
3395 CHAR *subaddr,
3396 T_ACI_TOS *tos)
3397
3398 {
3399 UBYTE idx; /* holds index counter */
3400
3401 /* Check if CC State is CS ACT REQ */
3402 //TISH, OMAPS00130688
3403 //start
3404 #if 0
3405 if (ctbIdx > NO_ENTRY AND
3406 psaCC_ctb(ctbIdx)->calStat EQ CS_ACT_REQ AND
3407 psaCC_ctb(ctbIdx)->calType EQ CT_MOC)
3408 #else
3409 if (ctbIdx > NO_ENTRY AND
3410 ((psaCC_ctb(ctbIdx)->calStat EQ CS_ACT_REQ) OR
3411 (psaCC_ctb(ctbIdx)->calStat EQ CS_ACT AND cssx_code EQ CSSX_CODE_CFUActive) OR
3412 (psaCC_ctb(ctbIdx)->calStat EQ CS_DSC_REQ)) AND
3413 psaCC_ctb(ctbIdx)->calType EQ CT_MOC)
3414 #endif
3415 //end
3416 {
3417 T_ACI_CSSI_CODE cssi_code;
3418 /* Implements Measure 90,91 */
3419 if( (cssx_code <= CSSX_CODE_DeflectedCall ) AND
3420 (cssx_code >= CSSX_CODE_ForwardedCall))
3421 {
3422 cssi_code = ( T_ACI_CSSI_CODE ) cssx2I_Code_Convert[cssx_code];
3423 }
3424 else
3425 {
3426 cssi_code = CSSI_CODE_NotPresent;
3427 }
3428 if (cssi_code NEQ CSSI_CODE_NotPresent
3429 /* Added as we want comparison to 255 */
3430 AND (cssi_code NEQ CSSI_CODE_Biggest )
3431 )
3432 {
3433 //TISH patch for OMAPS00130689
3434 //start
3435 #if 0
3436 S8 source = psaCC_ctb(ctbIdx)->curSrc;
3437 R_AT( RAT_CSSI, (T_ACI_CMD_SRC)source)( cssi_code, index );
3438 #else
3439 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
3440 {
3441 R_AT( RAT_CSSI, idx )(cssi_code, index);
3442 }
3443 #endif
3444 //end
3445 }
3446 }
3447 else /* (calldirection EQ CT_MTC) */
3448 {
3449 /* Sent CSSU TO ALL */
3450 T_ACI_CSSU_CODE cssu_code;
3451 /* Implements Measure 90,91 */
3452 /******************
3453 * Since there is a one-to-one mapping between CSSU and CSSX,
3454 * Hence we have not implemented any table for converting
3455 * CSSX codes to CSSU codes.
3456 ******************/
3457 cssu_code = CSSU_CODE_NotPresent;
3458
3459 if ( cssx_code EQ CSSX_CODE_DeflectedCall )
3460 {
3461 cssu_code = CSSU_CODE_DeflectedCall;
3462 }
3463 else if ( cssx_code EQ CSSX_CODE_IncCallForwarded)
3464 {
3465 cssu_code = CSSU_CODE_IncCallForwarded;
3466 }
3467 else if ( cssx_code <= CSSX_CODE_ECTConnect AND
3468 cssx_code >= CSSX_CODE_ForwardedCall )
3469 {
3470 cssu_code = ( T_ACI_CSSU_CODE ) cssx_code;
3471 }
3472 if (cssu_code != CSSU_CODE_NotPresent )
3473 {
3474 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
3475 {
3476 R_AT( RAT_CSSU, (T_ACI_CMD_SRC)idx )(cssu_code, index, number, toa, subaddr, tos);
3477 }
3478 }
3479 }
3480 }
3481
3482
3483
3484 LOCAL void cmhCC_NotifySS_v_ssCode( SHORT cId, T_NOTIFY_SS_INV *ntfySS )
3485 {
3486 CHAR numBuf[MAX_B_SUBSCR_NUM_LEN]; /* buffer for number */
3487 T_ACI_TOA toa; /* holds type of address */
3488 CHAR subBuf[MAX_SUBADDR_LEN]; /* buffer for subaddress */
3489 T_ACI_TOS tos; /* holds type of subaddress */
3490
3491 TRACE_FUNCTION ("cmhCC_NotifySS_v_ssCode()");
3492
3493 switch( ntfySS -> notifySSArg.ssCode )
3494 {
3495 case( SS_CD_ALL_FWSS ):
3496 case( SS_CD_CFU ):
3497 if( ntfySS -> notifySSArg.v_ssStatus AND
3498 ntfySS -> notifySSArg.ssStatus & SSS_A )
3499 {
3500 send_CSSX_notification(cId,
3501 CSSX_CODE_CFUActive,
3502 ACI_NumParmNotPresent,
3503 NULL, NULL, NULL, NULL);
3504 }
3505 break;
3506
3507 case( SS_CD_CFB ):
3508 case( SS_CD_CFNRY ):
3509 case( SS_CD_CFNRC ):
3510 case( SS_CD_ALL_CFWSS ):
3511
3512 if( ntfySS -> notifySSArg.v_ssStatus AND
3513 ntfySS -> notifySSArg.ssStatus & SSS_A )
3514 {
3515
3516 send_CSSX_notification(cId,
3517 CSSX_CODE_SomeCCFActive,
3518 ACI_NumParmNotPresent,
3519 NULL, NULL, NULL, NULL);
3520 }
3521 break;
3522
3523 case( SS_CD_ALL_CBSS ):
3524
3525 if( ntfySS -> notifySSArg.v_ssStatus AND
3526 ntfySS -> notifySSArg.ssStatus & SSS_A )
3527 {
3528 /* RAT_CSSI ... outgoing calls are barred */
3529 /* RAT_CSSI ... incoming calls are barred */
3530 send_CSSX_notification(cId,
3531 CSSX_CODE_OutCallsBarred,
3532 ACI_NumParmNotPresent,
3533 NULL, NULL, NULL, NULL);
3534
3535 send_CSSX_notification(cId,
3536 CSSX_CODE_IncCallsBarred,
3537 ACI_NumParmNotPresent,
3538 NULL, NULL, NULL, NULL);
3539
3540 }
3541 break;
3542
3543 case( SS_CD_BOC ):
3544 case( SS_CD_BAOC ):
3545 case( SS_CD_BOIC ):
3546 case( SS_CD_BOICXH ):
3547
3548 if( ntfySS -> notifySSArg.v_ssStatus AND
3549 ntfySS -> notifySSArg.ssStatus & SSS_A )
3550 {
3551 /* RAT_CSSI ... outgoing calls are barred */
3552 send_CSSX_notification(cId,
3553 CSSX_CODE_OutCallsBarred,
3554 ACI_NumParmNotPresent,
3555 NULL, NULL, NULL, NULL);
3556
3557 }
3558 break;
3559
3560 case( SS_CD_BIC ):
3561 case( SS_CD_BAIC ):
3562 case( SS_CD_BICRM ):
3563
3564 if( ntfySS -> notifySSArg.v_ssStatus AND
3565 ntfySS -> notifySSArg.ssStatus & SSS_A )
3566 {
3567 /* RAT_CSSI ... incoming calls are barred */
3568 send_CSSX_notification(cId,
3569 CSSX_CODE_IncCallsBarred,
3570 ACI_NumParmNotPresent,
3571 NULL, NULL, NULL, NULL);
3572
3573 }
3574 break;
3575
3576 case( SS_CD_CD ):
3577 if (ntfySS->notifySSArg.v_ssNotification AND
3578 ntfySS->notifySSArg.ssNotification.fwdSubscriber EQ
3579 FWD_C_INC_CALL_FWD)
3580 {
3581 /*
3582 * If alerting is allowed now, send the CSSU indication.
3583 * Otherwise just remember that we got this notification.
3584 */
3585 if ((ccShrdPrm.TCHasg EQ TRUE) OR
3586 (psaCC_ctb(cId)->sigInf NEQ MNCC_SIG_NOT_PRES))
3587
3588 {
3589 /*
3590 * The conditions for user alerting are fulfilled.
3591 * Send the +CSSU: unsolicited result code now.
3592 */
3593 send_CSSX_notification(cId,
3594 CSSX_CODE_DeflectedCall,
3595 ACI_NumParmNotPresent,
3596 psaCC_ctbRdrAdr2Num (cId, numBuf, sizeof (numBuf)),
3597 cmhCC_ctbGetRdrNumTyp (cId, &toa),
3598 psaCC_ctbRdrAdr2Sub (cId, subBuf),
3599 cmhCC_ctbGetRdrSubTyp (cId, &tos));
3600
3601 psaCC_FreeRdrPty (cId);
3602 psaCC_ctb(cId)->CDStat = NO_VLD_CD;
3603 }
3604 else
3605 {
3606 /*
3607 * Indication of the MT call towards the MMI is deferred until
3608 * the alerting conditions are fulfilled (TCH assignment).
3609 */
3610 psaCC_ctb(cId)->CDStat = CD_Notified;
3611 }
3612 return;
3613 }
3614
3615 if (ntfySS->notifySSArg.v_ssNotification AND
3616 ntfySS->notifySSArg.ssNotification.clgSubscriber EQ
3617 CLG_A_OUTG_CALL_FWD_C)
3618 {
3619 /* RAT_CSSI ... outgoing call has been deflected */
3620 send_CSSX_notification(cId,
3621 CSSX_CODE_DeflectedCall,
3622 ACI_NumParmNotPresent,
3623 NULL, NULL, NULL, NULL);
3624
3625 }
3626 break;
3627
3628 default:
3629 TRACE_EVENT( "UNHANDLED SS-CODE IN NOTIFY" );
3630 break;
3631 }
3632 }
3633
3634 LOCAL void cmhCC_NotifySS_v_ssNotification( SHORT cId, T_NOTIFY_SS_INV *ntfySS )
3635 {
3636
3637 TRACE_FUNCTION ("cmhCC_NotifySS_v_ssNotification()");
3638
3639 if( ntfySS -> notifySSArg.ssNotification.clgSubscriber EQ
3640 CLG_A_OUTG_CALL_FWD_C )
3641 {
3642 /* RAT_CSSI ... outgoing call has been forwarded */
3643 send_CSSX_notification(cId,
3644 CSSX_CODE_ForwardedCall,
3645 ACI_NumParmNotPresent,
3646 NULL, NULL, NULL, NULL);
3647 }
3648
3649 if( ntfySS -> notifySSArg.ssNotification.fwgSubscriber EQ
3650 FWG_B_INC_CALL_FWD_C )
3651 {
3652 /* RAT_CSSU ... this call is forwarded to C-Subsciber */
3653 send_CSSX_notification(cId,
3654 CSSX_CODE_IncCallForwarded,
3655 ACI_NumParmNotPresent ,
3656 NULL, NULL, NULL, NULL);
3657
3658 }
3659
3660 if( ntfySS -> notifySSArg.ssNotification.fwdSubscriber EQ
3661 FWD_C_INC_CALL_FWD )
3662 {
3663 /* RAT_CSSU ... this is a forwarded call */
3664 send_CSSX_notification(cId,
3665 CSSX_CODE_ForwardedCall,
3666 ACI_NumParmNotPresent ,
3667 NULL, NULL, NULL, NULL);
3668
3669 }
3670 }
3671
3672
3673 LOCAL void cmhCC_NotifySS_v_ectIndicator( SHORT cId, T_NOTIFY_SS_INV *ntfySS )
3674 {
3675 CHAR numBuf[MAX_B_SUBSCR_NUM_LEN]; /* buffer for number */
3676 T_ACI_TOA toa; /* holds type of address */
3677 CHAR subBuf[MAX_SUBADDR_LEN]; /* buffer for subaddress */
3678 T_ACI_TOS tos; /* holds type of subaddress */
3679 BOOL numFlg = FALSE; /* flags a present number */
3680 BOOL subFlg = FALSE; /* flags a present subaddress */
3681
3682 TRACE_FUNCTION ("cmhCC_NotifySS_v_ectIndicator()");
3683
3684 /* note that according to GSM 04.91, indications without RDN are
3685 possible but not without ectCallState */
3686 if( ntfySS -> notifySSArg.ectIndicator.v_ectCallState )
3687 {
3688 /* (G)ACI-FIX-1415 */
3689 if(ntfySS -> notifySSArg.ectIndicator.v_rdn )
3690 {
3691 if( ntfySS -> notifySSArg.ectIndicator.
3692 rdn.v_presentationAllowedAddress )
3693 {
3694 if( ntfySS -> notifySSArg.ectIndicator.
3695 rdn.presentationAllowedAddress.v_partyNumber AND
3696 ntfySS -> notifySSArg.ectIndicator.
3697 rdn.presentationAllowedAddress.partyNumber.c_bcdDigit )
3698 {
3699 utl_BCD2DialStr
3700 (ntfySS -> notifySSArg.ectIndicator.
3701 rdn.presentationAllowedAddress.partyNumber.bcdDigit,
3702 numBuf,
3703 ntfySS -> notifySSArg.ectIndicator.
3704 rdn.presentationAllowedAddress.partyNumber.c_bcdDigit);
3705
3706 toa.npi = (T_ACI_TOA_NPI)ntfySS -> notifySSArg.ectIndicator.
3707 rdn.presentationAllowedAddress.partyNumber.npi;
3708 toa.ton = (T_ACI_TOA_TON)ntfySS -> notifySSArg.ectIndicator.
3709 rdn.presentationAllowedAddress.partyNumber.noa;
3710
3711 numFlg = TRUE;
3712 }
3713
3714 if( ntfySS -> notifySSArg.ectIndicator.
3715 rdn.presentationAllowedAddress.v_partySubaddress AND
3716 ntfySS -> notifySSArg.ectIndicator.
3717 rdn.presentationAllowedAddress.partySubaddress.c_subadr_str )
3718 {
3719 utl_BCD2DialStr
3720 (ntfySS -> notifySSArg.ectIndicator.
3721 rdn.presentationAllowedAddress.partySubaddress.subadr_str,
3722 subBuf,
3723 ntfySS -> notifySSArg.ectIndicator.
3724 rdn.presentationAllowedAddress.partySubaddress.c_subadr_str);
3725
3726 tos.tos = (T_ACI_TOS_TOS)ntfySS -> notifySSArg.ectIndicator.
3727 rdn.presentationAllowedAddress.partySubaddress.tos;
3728 tos.oe = (T_ACI_TOS_OE)ntfySS -> notifySSArg.ectIndicator.
3729 rdn.presentationAllowedAddress.partySubaddress.oei;
3730
3731 subFlg = TRUE;
3732 }
3733 }
3734 /* check if the override case occured, do present RDN, (G)ACI-FIX-1434 */
3735 /* if presentationAllowedAddress is present then it is obsolete to look
3736 at presentationRestrictedAddress */
3737 else if( ntfySS -> notifySSArg.ectIndicator.
3738 rdn.v_presentationRestrictedAddress )
3739 {
3740 if( ntfySS -> notifySSArg.ectIndicator.
3741 rdn.presentationRestrictedAddress.v_partyNumber AND
3742 ntfySS -> notifySSArg.ectIndicator.
3743 rdn.presentationRestrictedAddress.partyNumber.c_bcdDigit )
3744 {
3745 utl_BCD2DialStr
3746 (ntfySS -> notifySSArg.ectIndicator.
3747 rdn.presentationRestrictedAddress.partyNumber.bcdDigit,
3748 numBuf,
3749 ntfySS -> notifySSArg.ectIndicator.
3750 rdn.presentationRestrictedAddress.partyNumber.c_bcdDigit);
3751
3752 toa.npi = (T_ACI_TOA_NPI)ntfySS -> notifySSArg.ectIndicator.
3753 rdn.presentationRestrictedAddress.partyNumber.npi;
3754 toa.ton = (T_ACI_TOA_TON)ntfySS -> notifySSArg.ectIndicator.
3755 rdn.presentationRestrictedAddress.partyNumber.noa;
3756
3757 numFlg = TRUE;
3758 }
3759
3760 if( ntfySS -> notifySSArg.ectIndicator.
3761 rdn.presentationRestrictedAddress.v_partySubaddress AND
3762 ntfySS -> notifySSArg.ectIndicator.
3763 rdn.presentationRestrictedAddress.partySubaddress.c_subadr_str )
3764 {
3765 utl_BCD2DialStr
3766 (ntfySS -> notifySSArg.ectIndicator.
3767 rdn.presentationRestrictedAddress.partySubaddress.subadr_str,
3768 subBuf,
3769 ntfySS -> notifySSArg.ectIndicator.
3770 rdn.presentationRestrictedAddress.partySubaddress.c_subadr_str);
3771
3772 tos.tos = (T_ACI_TOS_TOS)ntfySS -> notifySSArg.ectIndicator.
3773 rdn.presentationRestrictedAddress.partySubaddress.tos;
3774 tos.oe = (T_ACI_TOS_OE)ntfySS -> notifySSArg.ectIndicator.
3775 rdn.presentationRestrictedAddress.partySubaddress.oei;
3776
3777 subFlg = TRUE;
3778 }
3779 }
3780 }
3781
3782 switch( ntfySS -> notifySSArg.ectIndicator.ectCallState )
3783 {
3784 case( ECT_CS_ALERTING ):
3785 /* RAT_CSSU ... ECT alerting */
3786 send_CSSX_notification(cId,
3787 CSSX_CODE_ECTAlert,
3788 ACI_NumParmNotPresent,
3789 (numFlg)?numBuf:NULL,
3790 (numFlg)?&toa:NULL,
3791 (subFlg)?subBuf:NULL,
3792 (subFlg)?&tos:NULL);
3793 break;
3794
3795 case( ECT_CS_ACTIVE ):
3796 /* RAT_CSSU ... ECT active */
3797 send_CSSX_notification(cId,
3798 CSSX_CODE_ECTConnect,
3799 ACI_NumParmNotPresent,
3800 (numFlg)?numBuf:NULL,
3801 (numFlg)?&toa:NULL,
3802 (subFlg)?subBuf:NULL,
3803 (subFlg)?&tos:NULL);
3804
3805 break;
3806 }
3807 }
3808 }
3809
3810 LOCAL void cmhCC_NotifySS_v_ccbsf( T_NOTIFY_SS_INV *ntfySS )
3811 {
3812 T_ACI_CCBS_SET ccbsSet; /* holds ccbs setting */
3813
3814 TRACE_FUNCTION ("cmhCC_NotifySS_v_ccbsf()");
3815
3816 if( ntfySS -> notifySSArg.ccbsf.v_ccbsIndex )
3817 {
3818 ccbsSet.idx = ntfySS -> notifySSArg.ccbsf.ccbsIndex;
3819 }
3820 else
3821 ccbsSet.idx = ACI_NumParmNotPresent;
3822
3823 if( ntfySS -> notifySSArg.ccbsf.v_b_subscriberNumber AND
3824 ntfySS -> notifySSArg.ccbsf.b_subscriberNumber.c_bcdDigit)
3825 {
3826 utl_BCD2DialStr
3827 (ntfySS -> notifySSArg.ccbsf.b_subscriberNumber.bcdDigit,
3828 ccbsSet.number,
3829 ntfySS -> notifySSArg.ccbsf.b_subscriberNumber.c_bcdDigit);
3830
3831 ccbsSet.type.npi = (T_ACI_TOA_NPI)ntfySS -> notifySSArg.ccbsf.b_subscriberNumber.npi;
3832 ccbsSet.type.ton = (T_ACI_TOA_TON)ntfySS -> notifySSArg.ccbsf.b_subscriberNumber.noa;
3833 }
3834 else
3835 {
3836 ccbsSet.number[0] = 0x0;
3837 ccbsSet.type.npi = NPI_NotPresent;
3838 ccbsSet.type.ton = TON_NotPresent;
3839 }
3840
3841 if( ntfySS -> notifySSArg.ccbsf.v_b_subscriberSubaddress AND
3842 ntfySS -> notifySSArg.ccbsf.b_subscriberSubaddress.c_subadr_str)
3843 {
3844 utl_BCD2DialStr
3845 (ntfySS -> notifySSArg.ccbsf.b_subscriberSubaddress.subadr_str,
3846 ccbsSet.subaddr,
3847 ntfySS -> notifySSArg.ccbsf.b_subscriberSubaddress.c_subadr_str);
3848
3849 ccbsSet.satype.tos = (T_ACI_TOS_TOS)ntfySS -> notifySSArg.ccbsf.b_subscriberSubaddress.tos;
3850 ccbsSet.satype.oe = (T_ACI_TOS_OE)ntfySS -> notifySSArg.ccbsf.b_subscriberSubaddress.oei;
3851 }
3852 else
3853 {
3854 ccbsSet.subaddr[0] = 0x0;
3855 ccbsSet.satype.tos = TOS_NotPresent;
3856 ccbsSet.satype.oe = OE_NotPresent;
3857 }
3858
3859 if( ntfySS -> notifySSArg.ccbsf.v_basicServiceGroup )
3860 ccbsSet.class_type = cmhSS_GetClass( (T_basicService*)&ntfySS -> notifySSArg.ccbsf.
3861 basicServiceGroup );
3862 else
3863 ccbsSet.class_type = CLASS_NotPresent;
3864
3865 if( ntfySS -> notifySSArg.v_alertingPattern )
3866 {
3867 ccbsSet.alrtPtn = (T_ACI_ALRT_PTRN)ntfySS -> notifySSArg.alertingPattern;
3868 }
3869 else
3870 {
3871 ccbsSet.alrtPtn = ALPT_NotPresent;
3872 }
3873
3874 cmhrat_ccbs( CMD_SRC_MAX, CCBS_IND_Recall,
3875 CCBS_STAT_NotPresent, &ccbsSet );
3876 }
3877
3878
3879 GLOBAL void cmhCC_NotifySS( SHORT cId, T_NOTIFY_SS_INV *ntfySS )
3880 {
3881 UBYTE idx; /* holds index counter */
3882 T_callingName *NameId; /* holds Name Identifier for CNAP */
3883
3884 TRACE_FUNCTION ("cmhCC_NotifySS()");
3885
3886 /* check SS code */
3887 if( ntfySS -> notifySSArg.v_ssCode )
3888 {
3889 cmhCC_NotifySS_v_ssCode( cId, ntfySS );
3890 }
3891
3892 /* check SS notification */
3893 if( ntfySS -> notifySSArg.v_ssNotification )
3894 {
3895 cmhCC_NotifySS_v_ssNotification( cId, ntfySS );
3896 }
3897
3898 /* check call is waiting indicator */
3899 if( ntfySS -> notifySSArg.v_callIsWaitingIndicator )
3900 {
3901 /* RAT_CSSI ... call is waiting */
3902 send_CSSX_notification(cId,
3903 CSSX_CODE_CallWaiting,
3904 ACI_NumParmNotPresent,
3905 NULL, NULL, NULL, NULL);
3906
3907 }
3908
3909 /* check call on hold indicator */
3910 if( ntfySS -> notifySSArg.v_callOnHoldIndicator )
3911 {
3912 switch( ntfySS -> notifySSArg.callOnHoldIndicator )
3913 {
3914 case( CHLD_CALL_RETRIEVED ):
3915 send_CSSX_notification(cId,
3916 CSSX_CODE_Retrieved,
3917 ACI_NumParmNotPresent ,
3918 NULL, NULL, NULL, NULL);
3919
3920 break;
3921
3922 case( CHLD_CALL_ON_HOLD ):
3923 /* RAT_CSSU ... call has been put on hold */
3924 send_CSSX_notification(cId,
3925 CSSX_CODE_OnHold,
3926 ACI_NumParmNotPresent ,
3927 NULL, NULL, NULL, NULL);
3928
3929 break;
3930 }
3931 }
3932
3933 /* check multparty indicator */
3934 if( ntfySS -> notifySSArg.v_mptyIndicator )
3935 {
3936 /* mptyStat equal to CS_ACT_REQ set it to CS_ACT
3937 required to place multiparty call on hold */
3938 if(psaCC_ctb(cId)->mptyStat EQ CS_ACT_REQ)
3939 {
3940 psaCC_ctb(cId)->mptyStat = CS_ACT;
3941 }
3942
3943 /* RAT_CSSU ... multiparty call entered */
3944 send_CSSX_notification(cId,
3945 CSSX_CODE_Multiparty,
3946 ACI_NumParmNotPresent ,
3947 NULL, NULL, NULL, NULL);
3948
3949 }
3950
3951 /* check CUG index */
3952 if( ntfySS -> notifySSArg.v_cugIndex )
3953 {
3954 send_CSSX_notification(cId,
3955 CSSX_CODE_CUGCall,
3956 ntfySS -> notifySSArg.cugIndex,
3957 NULL, NULL, NULL, NULL);
3958 }
3959
3960 /* check CLIR suppression */
3961 if( ntfySS -> notifySSArg.v_clirSuppressionRejected )
3962 {
3963 /* RAT_CSSI ... CLIR suppression rejected */
3964 send_CSSX_notification(cId,
3965 CSSX_CODE_CLIRSupRej,
3966 ACI_NumParmNotPresent,
3967 NULL, NULL, NULL, NULL);
3968
3969 }
3970
3971 /* check ECT indicator */
3972 if( ntfySS -> notifySSArg.v_ectIndicator )
3973 {
3974 cmhCC_NotifySS_v_ectIndicator( cId, ntfySS );
3975 }
3976
3977 /* check CNAP indicator */
3978 if( ntfySS -> notifySSArg.v_nameIndicator )
3979 {
3980 if ( ntfySS -> notifySSArg.nameIndicator.v_callingName )
3981 {
3982 NameId = &(ntfySS -> notifySSArg.nameIndicator.callingName);
3983 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
3984 {
3985 R_AT( RAT_CNAP, (T_ACI_CMD_SRC)idx )
3986 ( NameId, CNAP_SERVICE_STATUS_NOT_PRESENT);
3987 }
3988 }
3989 }
3990
3991 /* check CCBS feature */
3992 if( ntfySS -> notifySSArg.v_ccbsf )
3993 {
3994 cmhCC_NotifySS_v_ccbsf( ntfySS );
3995 }
3996 }
3997
3998
3999 /*
4000 +------------------------------------------------------------------------------
4001 | Function : cmhCC_CheckSS
4002 +------------------------------------------------------------------------------
4003 | Description : check SS indication received.
4004 |
4005 | Parameters : cId -
4006 |
4007 | Return :
4008 +------------------------------------------------------------------------------
4009 */
4010 GLOBAL void cmhCC_CheckSS( SHORT cId )
4011 {
4012 UBYTE idx; /* holds index counter */
4013
4014 TRACE_FUNCTION ("cmhCC_CheckSS()");
4015
4016 /*
4017 *-------------------------------------------------------------------
4018 * indicate check SS
4019 *-------------------------------------------------------------------
4020 */
4021 /* RAT_CSSU ... forward check SS indication */
4022 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
4023 {
4024 send_CSSX_notification( cId,
4025 CSSX_CODE_FwrdCheckSS,
4026 ACI_NumParmNotPresent,
4027 NULL, NULL, NULL, NULL);
4028
4029 }
4030 }
4031
4032 /*
4033 +-------------------------------------------------------------------+
4034 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
4035 | ROUTINE : cmhCC_CCBSRegistered |
4036 +-------------------------------------------------------------------+
4037
4038 PURPOSE : call completion to busy subscriber successfully registered.
4039
4040 */
4041
4042 GLOBAL void cmhCC_CCBSRegistered( SHORT cId,
4043 T_ACC_REGISTER_CC_ENTRY_RES *CCBSreg )
4044 {
4045 UBYTE cmdBuf; /* buffers command */
4046 UBYTE srcBuf; /* buffers command source */
4047 T_ACI_CCBS_SET ccbsSet; /* holds ccbs setting */
4048
4049 TRACE_FUNCTION ("cmhCC_CCBSRegistered()");
4050
4051 /* check for command context */
4052 if( psaCC_ctb(cId)->curCmd NEQ AT_CMD_CHLD )
4053 {
4054 TRACE_EVENT("cmhCC_CCBSRegistered: wrong command context !");
4055 return;
4056 }
4057
4058 if( CCBSreg->accRegisterCCEntryRes.v_ccbsf )
4059 {
4060 if( CCBSreg->accRegisterCCEntryRes.ccbsf.v_ccbsIndex )
4061
4062 ccbsSet.idx = CCBSreg->accRegisterCCEntryRes.ccbsf.ccbsIndex;
4063 else
4064 ccbsSet.idx = ACI_NumParmNotPresent;
4065
4066
4067 if( CCBSreg->accRegisterCCEntryRes.ccbsf.
4068 v_b_subscriberNumber AND
4069 CCBSreg->accRegisterCCEntryRes.ccbsf.
4070 b_subscriberNumber.c_bcdDigit)
4071 {
4072 utl_BCD2DialStr
4073 (CCBSreg->accRegisterCCEntryRes.ccbsf.b_subscriberNumber.
4074 bcdDigit,
4075 ccbsSet.number,
4076 CCBSreg->accRegisterCCEntryRes.ccbsf.b_subscriberNumber.
4077 c_bcdDigit);
4078
4079 ccbsSet.type.npi = (T_ACI_TOA_NPI)CCBSreg->accRegisterCCEntryRes.ccbsf.
4080 b_subscriberNumber.npi;
4081 ccbsSet.type.ton = (T_ACI_TOA_TON)CCBSreg->accRegisterCCEntryRes.ccbsf.
4082 b_subscriberNumber.noa;
4083 }
4084 else
4085 {
4086 ccbsSet.number[0] = 0x0;
4087 ccbsSet.type.npi = NPI_NotPresent;
4088 ccbsSet.type.ton = TON_NotPresent;
4089 }
4090
4091 if( CCBSreg->accRegisterCCEntryRes.ccbsf.
4092 v_b_subscriberSubaddress AND
4093 CCBSreg->accRegisterCCEntryRes.ccbsf.
4094 b_subscriberSubaddress.c_subadr_str)
4095 {
4096 utl_BCD2DialStr
4097 (CCBSreg->accRegisterCCEntryRes.ccbsf.b_subscriberSubaddress.
4098 subadr_str,
4099 ccbsSet.subaddr,
4100 CCBSreg->accRegisterCCEntryRes.ccbsf.b_subscriberSubaddress.
4101 c_subadr_str);
4102
4103 ccbsSet.satype.tos = (T_ACI_TOS_TOS)CCBSreg->accRegisterCCEntryRes.ccbsf.
4104 b_subscriberSubaddress.tos;
4105 ccbsSet.satype.oe = (T_ACI_TOS_OE)CCBSreg->accRegisterCCEntryRes.ccbsf.
4106 b_subscriberSubaddress.oei;
4107 }
4108 else
4109 {
4110 ccbsSet.subaddr[0] = 0x0;
4111 ccbsSet.satype.tos = TOS_NotPresent;
4112 ccbsSet.satype.oe = OE_NotPresent;
4113 }
4114
4115 if( CCBSreg->accRegisterCCEntryRes.ccbsf.v_basicServiceGroup )
4116 ccbsSet.class_type = cmhSS_GetClass( (T_basicService*)&CCBSreg->accRegisterCCEntryRes.
4117 ccbsf.basicServiceGroup );
4118 else
4119 ccbsSet.class_type = CLASS_NotPresent;
4120
4121 ccbsSet.alrtPtn = ALPT_NotPresent;
4122 }
4123
4124 cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf);
4125 cmhCC_tstAndUnflagCall( cId, &(cmhPrm[srcBuf].ccCmdPrm.mltyDscFlg));
4126 psaCC_FreeCtbNtry (cId);
4127
4128 cmhrat_ccbs( srcBuf, CCBS_IND_Registered,
4129 CCBS_STAT_NotPresent, &ccbsSet );
4130
4131 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf );
4132
4133 /* log result */
4134 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_OK,
4135 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1), BS_SPEED_NotPresent,CME_ERR_NotPresent);
4136 }
4137
4138 /* sends RAT_CCBS: sometimes it is an intermediate result, and sometimes it is an
4139 indication.
4140 When srcId = CMD_SRC_MAX, it is an indication and shall go to all sources...
4141 Otherwise, only to the source specified... */
4142 GLOBAL void cmhrat_ccbs( UBYTE srcId,
4143 T_ACI_CCBS_IND ccbs_ind,
4144 T_ACI_CCBS_STAT status,
4145 T_ACI_CCBS_SET *setting )
4146 {
4147 #ifdef FF_ATI
4148 UBYTE idx;
4149 #endif
4150
4151 if( srcId EQ CMD_SRC_MAX )
4152 {
4153 #if defined MFW || defined SMI OR defined FF_MMI_RIV
4154 rAT_PercentCCBS(ccbs_ind, status, setting);
4155 #endif
4156
4157 #ifdef FF_ATI
4158 for( idx = CMD_SRC_ATI_1; idx < CMD_SRC_MAX; idx++ )
4159 {
4160 srcId_cb = idx;
4161 rCI_PercentCCBS(ccbs_ind, status, setting, FALSE);
4162 }
4163 #endif /* FF_ATI */
4164
4165 return;
4166 }
4167 #if defined MFW || defined SMI OR defined FF_MMI_RIV
4168 if( srcId EQ CMD_SRC_LCL )
4169 {
4170 rAT_PercentCCBS( ccbs_ind, status, setting );
4171 return;
4172 }
4173 #endif
4174
4175 /* else it is an ATI source */
4176 srcId_cb = srcId;
4177
4178 #ifdef FF_ATI
4179 rCI_PercentCCBS(ccbs_ind, status, setting, TRUE);
4180 #endif /* FF_ATI */
4181 }
4182
4183
4184 /*
4185 +-------------------------------------------------------------------+
4186 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
4187 | ROUTINE : cmhCC_CDRegistered |
4188 +-------------------------------------------------------------------+
4189
4190 PURPOSE : Call Deflection (CD) successfully registered.
4191
4192 */
4193
4194 GLOBAL void cmhCC_CDRegistered( SHORT cId )
4195 {
4196 TRACE_FUNCTION ("cmhCC_CDRegistered()");
4197
4198 switch( psaCC_ctb(cId)->curCmd )
4199 {
4200 case AT_CMD_CTFR:
4201 psaCC_ctb(cId)->CDStat = CD_Succeeded;
4202 break;
4203
4204 default: /* This is unexpected or network failure, ignore the event */
4205 break;
4206 }
4207 }
4208
4209
4210 /*
4211 +-------------------------------------------------------------------+
4212 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
4213 | ROUTINE : cmhCC_SSTransFail |
4214 +-------------------------------------------------------------------+
4215
4216 PURPOSE : SS transaction failed.
4217
4218 */
4219
4220 GLOBAL void cmhCC_SSTransFail ( SHORT cId )
4221 {
4222 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
4223 SHORT ctbIdx; /* holds call table index */
4224 SHORT addId; /* holds additional call id */
4225 UBYTE cmdBuf; /* buffers command */
4226 UBYTE srcBuf; /* buffers command source */
4227
4228 TRACE_FUNCTION ("cmhCC_SSTransFail()");
4229
4230 /*
4231 *-------------------------------------------------------------------
4232 * check for command context
4233 *-------------------------------------------------------------------
4234 */
4235 switch( psaCC_ctb(cId)->curCmd )
4236 {
4237 /*
4238 *----------------------------------------------------------------
4239 * process result for D and A command
4240 *----------------------------------------------------------------
4241 */
4242 case( AT_CMD_D ):
4243 case( AT_CMD_A ):
4244
4245 /* restore call status for hold request*/
4246 if( psaCC_ctb(cId)->calStat EQ CS_HLD_REQ )
4247 for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
4248 {
4249 if( ccShrdPrm.ctb[ctbIdx] NEQ NULL AND
4250 psaCC_ctb(ctbIdx)->calStat EQ CS_HLD_REQ AND
4251 psaCC_ctb(ctbIdx)->mptyStat EQ CS_ACT )
4252 {
4253 psaCC_ctb(ctbIdx)->calStat = CS_ACT;
4254 }
4255 }
4256
4257 pCCCmdPrm = &cmhPrm[psaCC_ctb(cId)->curSrc].ccCmdPrm;
4258
4259 cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf);
4260
4261 if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyCncFlg)))
4262 {
4263 if( pCCCmdPrm -> CHLDmode EQ CHLD_MOD_HldActDial AND
4264 pCCCmdPrm -> mltyCncFlg )
4265 {
4266 for( addId = 0; !((pCCCmdPrm -> mltyCncFlg >> addId) & 0x01); addId++ )
4267 ;
4268
4269 if( CHLDaddInfo EQ CHLD_ADD_INFO_DIAL_CAL )
4270 {
4271 CHLDaddInfo = NO_CHLD_ADD_INFO;
4272 psaCC_FreeCtbNtry (addId); /* remove pending call */
4273 }
4274 }
4275
4276 pCCCmdPrm -> mltyCncFlg = 0; /* unflag calls */
4277 //TISH, patch for OMAPS00129157
4278 //start
4279 if (psaCC_ctb(cId)->failType == SSF_ERR_PRB && psaCC_ctb(cId)->errCd == 0x0a)
4280 R_AT( RAT_CME, srcBuf ) ( cmdBuf, CME_ERR_OpNotAllow);
4281 else
4282 //end
4283 R_AT( RAT_CME, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf, CME_ERR_NotPresent );
4284
4285 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_CME,
4286 (T_ACI_AT_CMD)cmdBuf, -1, BS_SPEED_NotPresent, CME_ERR_NotPresent );
4287 }
4288 break;
4289
4290 /*
4291 *----------------------------------------------------------------
4292 * process result for +CTFR command
4293 *----------------------------------------------------------------
4294 */
4295 case( AT_CMD_CTFR ):
4296 psaCC_ctb(cId)->CDStat = CD_Failed;
4297 break;
4298
4299 /*
4300 *----------------------------------------------------------------
4301 * process result for +CHLD command
4302 *----------------------------------------------------------------
4303 */
4304 case( AT_CMD_CHLD ):
4305
4306 /* determine CHLD mode */
4307 switch( cmhPrm[psaCC_ctb(cId)->curSrc].ccCmdPrm.CHLDmode )
4308 {
4309 /*
4310 *------------------------------------------------------------
4311 * no multiparty relation
4312 *------------------------------------------------------------
4313 */
4314 case( CHLD_MOD_NotPresent ):
4315 case( CHLD_MOD_RelHldOrUdub ):
4316 case( CHLD_MOD_RelActSpec ):
4317
4318 TRACE_EVENT( "UNEXP CHLD MODE FOR SS ERROR COMP" );
4319 return;
4320
4321 /*
4322 *------------------------------------------------------------
4323 * multiparty hold or retrieve
4324 *------------------------------------------------------------
4325 */
4326 case( CHLD_MOD_RelActAndAcpt ):
4327 case( CHLD_MOD_HldActAndAcpt ):
4328
4329 /* restore call status for retrieve request */
4330 if( psaCC_ctb(cId)->calStat EQ CS_ACT_REQ )
4331 {
4332 for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
4333 {
4334 if( ccShrdPrm.ctb[ctbIdx] NEQ NULL AND
4335 psaCC_ctb(ctbIdx)->calStat EQ CS_ACT_REQ AND
4336 psaCC_ctb(ctbIdx)->mptyStat EQ CS_ACT )
4337 {
4338 psaCC_ctb(ctbIdx)->calStat = CS_HLD;
4339 }
4340 }
4341 psaCC_MPTY (cId, MNCC_MPTY_RETRIEVE_FAIL);
4342 }
4343
4344 /* restore call status for hold request*/
4345 if( psaCC_ctb(cId)->calStat EQ CS_HLD_REQ )
4346 {
4347 for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
4348 {
4349 if( ccShrdPrm.ctb[ctbIdx] NEQ NULL AND
4350 psaCC_ctb(ctbIdx)->calStat EQ CS_HLD_REQ AND
4351 psaCC_ctb(ctbIdx)->mptyStat EQ CS_ACT )
4352 {
4353 psaCC_ctb(ctbIdx)->calStat = CS_ACT;
4354 }
4355 }
4356 psaCC_MPTY (cId, MNCC_MPTY_HOLD_FAIL);
4357 }
4358
4359 break;
4360
4361 /*
4362 *------------------------------------------------------------
4363 * multiparty split
4364 *------------------------------------------------------------
4365 */
4366 case( CHLD_MOD_HldActExc ):
4367
4368 psaCC_ctb(cId)->mptyStat = CS_ACT;
4369 psaCC_MPTY (cId, MNCC_MPTY_SPLIT_FAIL);
4370 break;
4371
4372 /*
4373 *------------------------------------------------------------
4374 * multiparty build
4375 *------------------------------------------------------------
4376 */
4377 case( CHLD_MOD_AddHld ):
4378
4379 /* restore call status for build request */
4380 for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
4381 {
4382 if( ccShrdPrm.ctb[ctbIdx] NEQ NULL AND
4383 psaCC_ctb(ctbIdx)->mptyStat EQ CS_ACT_REQ AND
4384 psaCC_ctb(ctbIdx)->calStat EQ CS_HLD )
4385 {
4386 psaCC_ctb(ctbIdx)->mptyStat = CS_IDL;
4387 }
4388 }
4389
4390 if( psaCC_ctb(cId)->mptyStat EQ CS_ACT_REQ )
4391 psaCC_ctb(cId)->mptyStat = CS_IDL;
4392 psaCC_MPTY (cId, MNCC_MPTY_BUILD_FAIL);
4393 break;
4394
4395 /*
4396 *------------------------------------------------------------
4397 * explicit call transfer
4398 *------------------------------------------------------------
4399 */
4400 case( CHLD_MOD_Ect ):
4401 pCCCmdPrm = &cmhPrm[psaCC_ctb(cId)->curSrc].ccCmdPrm;
4402 TRACE_EVENT("ECT failed...");
4403
4404 TIMERSTOP( ACI_TECT );
4405
4406 pCCCmdPrm->CHLDmode = CHLD_MOD_NotPresent;
4407
4408 /* restore call status for other call that was to be transfered */
4409 for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ )
4410 {
4411 if( ctbIdx EQ cId )
4412 {
4413 continue;
4414 }
4415 else if (ccShrdPrm.ctb[ctbIdx] NEQ NULL AND
4416 cmhCC_tstAndUnflagCall( ctbIdx, &(pCCCmdPrm -> mltyDscFlg)) AND
4417 psaCC_ctb(ctbIdx)->curCmd EQ AT_CMD_CHLD )
4418 {
4419 /* then it is the second call id */
4420 cmhCC_PrepareCmdEnd (ctbIdx, NULL, NULL);
4421 }
4422 }
4423
4424 /* restore first call id parameters */
4425 cmhCC_PrepareCmdEnd (cId, NULL, &srcBuf);
4426
4427 if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyDscFlg)) )
4428 {
4429 R_AT( RAT_CME, (T_ACI_CMD_SRC)srcBuf )
4430 ( AT_CMD_CHLD, CME_ERR_Unknown );
4431
4432 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_CME,
4433 AT_CMD_CHLD, -1, BS_SPEED_NotPresent, CME_ERR_Unknown );
4434 }
4435 return;
4436
4437 /*
4438 *------------------------------------------------------------
4439 * call completion to busy subscriber
4440 *------------------------------------------------------------
4441 */
4442 case( CHLD_MOD_Ccbs ):
4443 pCCCmdPrm = &cmhPrm[psaCC_ctb(cId)->curSrc].ccCmdPrm;
4444 TRACE_EVENT("CCBS failed...");
4445
4446 /* restore first call id parameters */
4447 cmhCC_PrepareCmdEnd (cId, NULL, &srcBuf);
4448
4449 if( psaCC_ctb(cId)->opCode EQ OPC_ACC_REGISTER_CC_ENTRY )
4450 psaCC_FreeCtbNtry (cId); /* remove call table entry */
4451
4452 if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyDscFlg)) )
4453 {
4454 pCCCmdPrm -> mltyDscFlg = 0; /* unflag calls */
4455
4456 R_AT( RAT_CME, (T_ACI_CMD_SRC)srcBuf )
4457 ( AT_CMD_CHLD, CME_ERR_Unknown );
4458
4459 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_CME,
4460 AT_CMD_CHLD, -1, BS_SPEED_NotPresent, CME_ERR_Unknown );
4461 }
4462 return;
4463 }
4464
4465 pCCCmdPrm = &cmhPrm[psaCC_ctb(cId)->curSrc].ccCmdPrm;
4466 cmhCC_PrepareCmdEnd (cId, NULL, &srcBuf);
4467
4468 if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyCncFlg)))
4469 {
4470 pCCCmdPrm -> mltyCncFlg = 0; /* unflag calls */
4471
4472 R_AT( RAT_CME, (T_ACI_CMD_SRC)srcBuf ) ( AT_CMD_CHLD, CME_ERR_Unknown );
4473
4474 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_CME,
4475 AT_CMD_CHLD, -1, BS_SPEED_NotPresent, CME_ERR_Unknown );
4476 }
4477
4478 break;
4479 }
4480
4481 return;
4482 }
4483
4484 /*
4485 +-------------------------------------------------------------------+
4486 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
4487 | ROUTINE : cmhCC_MPTYTimeout |
4488 +-------------------------------------------------------------------+
4489
4490 PURPOSE : handle multiparty timeout
4491
4492 */
4493
4494 GLOBAL void cmhCC_MPTYTimeout ( void )
4495 {
4496 TRACE_FUNCTION( "cmhCC_MPTYTimeout()" );
4497
4498 if (!psaCC_ctbIsValid (ccShrdPrm.cIdMPTY))
4499 {
4500 TRACE_ERROR ("ccShrdPrm.cIdMPTY invalid");
4501 return;
4502 }
4503
4504 /*
4505 *-------------------------------------------------------------------
4506 * SS failure
4507 *-------------------------------------------------------------------
4508 */
4509 #ifdef SIM_TOOLKIT
4510 if (psaCC_ctb(ccShrdPrm.cIdMPTY)->SATinv )
4511 {
4512 psaCC_ctb(ccShrdPrm.cIdMPTY)->SATinv = FALSE;
4513 /* return network error cause GSM 11.14 / 12.12.3 */
4514 cmhSAT_NtwErr( ADD_NO_CAUSE );
4515 }
4516 #endif
4517 cmhCC_SSTransFail(ccShrdPrm.cIdMPTY);
4518
4519 }
4520
4521 /*
4522 +-------------------------------------------------------------------+
4523 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
4524 | ROUTINE : cmhCC_ECTTimeout |
4525 +-------------------------------------------------------------------+
4526
4527 PURPOSE : handle explicit call transfer timeout
4528
4529 */
4530
4531 LOCAL SHORT search_ect_call(void)
4532 {
4533 SHORT idx;
4534 UBYTE chld_src;
4535
4536 for(idx = 0; idx < MAX_CALL_NR; idx++)
4537 {
4538 if (ccShrdPrm.ctb[idx] NEQ NULL AND
4539 psaCC_ctb(idx)->curCmd EQ AT_CMD_CHLD)
4540 {
4541 chld_src = psaCC_ctb(idx)->curSrc;
4542
4543 if( cmhPrm[chld_src].ccCmdPrm.CHLDmode EQ CHLD_MOD_Ect )
4544 {
4545 return(idx);
4546 }
4547 }
4548 }
4549 return(NO_ENTRY);
4550 }
4551
4552 GLOBAL void cmhCC_ECTTimeout ( void )
4553 {
4554 SHORT ectId;
4555
4556 TRACE_FUNCTION( "cmhCC_ECTTimeout()" );
4557
4558 ectId = search_ect_call( );
4559
4560 if (ectId NEQ NO_ENTRY)
4561 cmhCC_SSTransFail(ectId);
4562 }
4563
4564 #ifdef FF_TTY
4565 /*
4566 +-------------------------------------------------------------------+
4567 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
4568 | ROUTINE : cmhCC_TTY_Control |
4569 +-------------------------------------------------------------------+
4570
4571 PURPOSE : Enabling/disabling TTY for the active call
4572
4573 */
4574
4575 LOCAL BOOL cmhCC_TTY_Proceed (SHORT cId)
4576 {
4577 T_TTY_CMD ttyAction = TTY_OFF;
4578 T_MNCC_bcpara *bc;
4579
4580 if (ccShrdPrm.ctb[cId] NEQ NULL)
4581 {
4582 /* Call table entry exists */
4583 bc = &psaCC_ctb(cId)->BC[psaCC_ctb(cId)->curBC];
4584
4585 if ((bc->bearer_serv EQ MNCC_BEARER_SERV_SPEECH_CTM OR
4586 bc->bearer_serv EQ MNCC_BEARER_SERV_AUX_SPEECH_CTM) AND
4587 psaCC_ctb(cId)->calStat NEQ CS_DSC_REQ)
4588 {
4589 if ((ccShrdPrm.chMod EQ MNCC_CHM_SPEECH) OR
4590 (ccShrdPrm.chMod EQ MNCC_CHM_SPEECH_V2) OR
4591 (ccShrdPrm.chMod EQ MNCC_CHM_SPEECH_V3))
4592 {
4593 audio_set_tty (ttyAction = (T_TTY_CMD)ccShrdPrm.ttyCmd);
4594 }
4595 else
4596 {
4597 TRACE_EVENT_P1 ("TTY no speech mode: %d", (int)ccShrdPrm.chMod);
4598 }
4599 }
4600 else
4601 {
4602 TRACE_EVENT_P1 ("TTY wrong BCAP: %d", (int)bc->bearer_serv);
4603 }
4604
4605 if (ttyAction NEQ (UBYTE)TTY_OFF)
4606 {
4607 cmhCC_notifyTTY (CTTY_NEG_Grant, cmhCC_getTTYtrx_state (ttyAction));
4608 return TRUE;
4609 }
4610 else
4611 {
4612 cmhCC_notifyTTY (((ccShrdPrm.ctmReq EQ MNCC_CTM_ENABLED)?
4613 CTTY_NEG_Reject: CTTY_NEG_None),
4614 CTTY_TRX_Unknown);
4615 }
4616 }
4617 else
4618 {
4619 TRACE_EVENT ("TTY no call table entry");
4620 }
4621
4622 return FALSE;
4623 }
4624
4625 GLOBAL void cmhCC_TTY_Control (SHORT cId, UBYTE action)
4626 {
4627 TRACE_EVENT_P3 ("TTY event %d, old state %d, callId %d",
4628 action, ccShrdPrm.ctmState, cId);
4629
4630 if (!ccShrdPrm.TCHasg)
4631 {
4632 TRACE_EVENT ("TTY: no TCH");
4633 }
4634 switch (action)
4635 {
4636 case TTY_TCH:
4637 if (ccShrdPrm.ctmState EQ TTY_STATE_IDLE)
4638 {
4639 ccShrdPrm.ctmState = TTY_STATE_SYNC;
4640 }
4641 else if (ccShrdPrm.ctmState EQ TTY_STATE_BCAP)
4642 {
4643 if (cmhCC_TTY_Proceed (cId))
4644 ccShrdPrm.ctmState = TTY_STATE_ACTIVE;
4645 else
4646 ccShrdPrm.ctmState = TTY_STATE_WAIT;
4647 }
4648 break;
4649
4650 case TTY_START:
4651 if (ccShrdPrm.ctmState EQ TTY_STATE_IDLE)
4652 {
4653 ccShrdPrm.ctmState = TTY_STATE_BCAP;
4654 }
4655 else if (ccShrdPrm.ctmState EQ TTY_STATE_SYNC)
4656 {
4657 if (cmhCC_TTY_Proceed (cId))
4658 ccShrdPrm.ctmState = TTY_STATE_ACTIVE;
4659 else
4660 ccShrdPrm.ctmState = TTY_STATE_WAIT;
4661 }
4662 break;
4663
4664 case TTY_PAUSE:
4665 if (ccShrdPrm.ctmState EQ TTY_STATE_WAIT)
4666 {
4667 ccShrdPrm.ctmState = TTY_STATE_SYNC;
4668 }
4669 else if (ccShrdPrm.ctmState EQ TTY_STATE_ACTIVE)
4670 {
4671 audio_set_tty (TTY_OFF);
4672 ccShrdPrm.ctmState = TTY_STATE_SYNC;
4673 }
4674 break;
4675
4676 case TTY_STOP:
4677 if (ccShrdPrm.ctmState EQ TTY_STATE_ACTIVE)
4678 {
4679 audio_set_tty (TTY_OFF);
4680 cmhCC_notifyTTY (CTTY_NEG_None, CTTY_TRX_Off);
4681 }
4682 ccShrdPrm.ctmState = (ccShrdPrm.ctmReq EQ MNCC_CTM_ENABLED)?
4683 TTY_STATE_IDLE: TTY_STATE_NONE;
4684 break;
4685
4686 default:
4687 break;
4688 }
4689 TRACE_EVENT_P1 ("TTY new state %d", ccShrdPrm.ctmState);
4690 }
4691 #endif /* FF_TTY */
4692
4693 #if defined (FF_WAP) || defined (FF_PPP) || defined (FF_GPF_TCPIP) || defined (FF_SAT_E)
4694 /* Only for WAP or RNET */
4695
4696 /*
4697 +-------------------------------------------------------------------+
4698 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
4699 | ROUTINE : cmhCC_PPP_Established |
4700 +-------------------------------------------------------------------+
4701
4702 PURPOSE : PPP entity activated, data path established
4703
4704 */
4705
4706 GLOBAL SHORT cmhCC_PPP_Established (ULONG ip_address, USHORT max_receive_unit,
4707 ULONG dns1, ULONG dns2)
4708 {
4709
4710 char c_ip_address[16],c_dns1[16],c_dns2[16];
4711
4712 #ifdef FF_PPP
4713 SHORT cId = raShrdPrm.cId;
4714 #endif /* FF_PPP */
4715
4716 TRACE_FUNCTION ("cmhCC_PPP_Established()");
4717
4718 ipAddress = ip_address;
4719 sprintf (c_ip_address, "%03u.%03u.%03u.%03u", (ip_address & 0xff000000) >> 24,
4720 (ip_address & 0x00ff0000) >> 16,
4721 (ip_address & 0x0000ff00) >> 8 ,
4722 (ip_address & 0x000000ff) );
4723
4724 sprintf(c_dns1, "%03u.%03u.%03u.%03u", (dns1 & 0xff000000) >> 24,
4725 (dns1 & 0x00ff0000) >> 16,
4726 (dns1 & 0x0000ff00) >> 8 ,
4727 (dns1 & 0x000000ff) );
4728
4729 sprintf(c_dns2, "%03u.%03u.%03u.%03u", (dns2 & 0xff000000) >> 24,
4730 (dns2 & 0x00ff0000) >> 16,
4731 (dns2 & 0x0000ff00) >> 8 ,
4732 (dns2 & 0x000000ff) );
4733
4734 TRACE_EVENT_P3("addr : %s ,dns1 : %s ,dns2: %s",c_ip_address,c_dns1,c_dns2);
4735
4736 if(is_gpf_tcpip_call()) {
4737 pppShrdPrm.ipaddr = ip_address ;
4738 pppShrdPrm.dns1 = dns1 ;
4739 pppShrdPrm.dns2 = dns2 ;
4740 }
4741 #if defined FF_PPP AND defined FAX_AND_DATA
4742 if (psaCC_ctbIsValid (cId) AND /* Ensure not to dereferentiate NULL */
4743 pppShrdPrm.is_PPP_CALL EQ TRUE)
4744 {
4745 pppShrdPrm.ipaddr = ip_address ;
4746 pppShrdPrm.dns1 = dns1 ;
4747 pppShrdPrm.dns2 = dns2 ;
4748 R_AT( RAT_CONNECT, raShrdPrm.owner )
4749 (psaCC_ctb(cId)->curCmd,
4750 cmhCC_GetDataRate(&psaCC_ctb(cId)->BC[psaCC_ctb(cId)->curBC]),
4751 cId+1,
4752 FALSE);
4753 return 0;
4754 }
4755 #endif /*FF_PPP*/
4756 #if defined (FF_SAT_E)
4757 if(cmhSAT_OpChnChckCSD(UDP))
4758 {
4759 psaTCPIP_Configure((UBYTE*)c_ip_address, NULL, NULL,
4760 (UBYTE*)c_dns1, (UBYTE*)c_dns2,max_receive_unit,
4761 cmhSAT_OpChnUDPConfCsd) ;
4762 }
4763 else
4764 #endif /* FF_SAT_E */
4765 #if defined (FF_WAP) || defined (FF_GPF_TCPIP)
4766 {
4767 psaTCPIP_Configure((UBYTE*)c_ip_address, NULL, NULL,
4768 (UBYTE*)c_dns1, (UBYTE*)c_dns1,max_receive_unit,
4769 psaTCPIP_conf_csd_callback) ;
4770 }
4771 #endif /* FF_WAP OR FF_GPF_TCPIP */
4772 return 0;
4773 }
4774
4775 #ifdef CO_UDP_IP
4776 /*
4777 +-------------------------------------------------------------------+
4778 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
4779 | ROUTINE : cmhCC_IPA_Configurated |
4780 +-------------------------------------------------------------------+
4781
4782 PURPOSE : IPA entity activated, data path established
4783 */
4784
4785 GLOBAL SHORT cmhCC_IPA_Configurated (void)
4786 {
4787 TRACE_FUNCTION ("cmhCC_IPA_Configurated()");
4788
4789 psaUDPA_Config(UDPA_CONFIG_UP);
4790
4791 return 0;
4792 }
4793
4794 /*
4795 +-------------------------------------------------------------------+
4796 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
4797 | ROUTINE : cmhCC_UDPA_Configurated |
4798 +-------------------------------------------------------------------+
4799
4800 PURPOSE : IPA entity activated, data path established
4801
4802 */
4803
4804 GLOBAL SHORT cmhCC_UDPA_Configurated (void)
4805 {
4806 TRACE_FUNCTION ("cmhCC_UDPA_Configurated()");
4807 #ifdef FF_WAP
4808 if (Wap_Call)
4809 {
4810 if ( tcpipShrdPrm.connection_type EQ TCPIP_CONNECTION_TYPE_CSD_WAP )
4811 {
4812 rAT_WAP_PPP_connected(wapId,ipAddress);
4813 }
4814 else
4815 {
4816 TRACE_EVENT_P1 ("IP: %s", tcpipShrdPrm.ipaddr);
4817 rAT_WAP_PPP_connected(wapId, psaTCPIP_bytes2ipv4addr(tcpipShrdPrm.ipaddr));
4818 }
4819 }
4820 #endif
4821 psaUDPIP_config_dispatch() ;
4822 return 0;
4823 }
4824
4825
4826 /*
4827 +-------------------------------------------------------------------+
4828 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
4829 | ROUTINE : cmhCC_UDPA_Deconfigurated |
4830 +-------------------------------------------------------------------+
4831
4832 PURPOSE :
4833
4834 */
4835
4836 GLOBAL SHORT cmhCC_UDPA_Deconfigurated (void)
4837 {
4838 TRACE_FUNCTION ("cmhCC_UDPA_Deconfigurated ()");
4839
4840 cmhUDPA_Deactivate(tcpipShrdPrm.src_id);
4841
4842 return 0;
4843 }
4844
4845 /*
4846 +-------------------------------------------------------------------+
4847 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
4848 | ROUTINE : cmhCC_IPA_Deconfigurated |
4849 +-------------------------------------------------------------------+
4850
4851 PURPOSE :
4852
4853 */
4854
4855 GLOBAL SHORT cmhCC_IPA_Deconfigurated (void)
4856 {
4857 TRACE_FUNCTION ("cmhCC_IPA_Deconfigurated()");
4858
4859 psaUDPA_Config(UDPA_CONFIG_DOWN);
4860
4861 return 0;
4862 }
4863
4864 #endif /* of WAP || SAT E */
4865
4866 /*
4867 +-------------------------------------------------------------------+
4868 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
4869 | ROUTINE : cmhCC_PPP_Terminated |
4870 +-------------------------------------------------------------------+
4871
4872 PURPOSE : PPP entity terminated, close connection / update CC parameters
4873
4874 */
4875
4876 GLOBAL SHORT cmhCC_PPP_Terminated ( void )
4877 {
4878 TRACE_FUNCTION ("cmhCC_PPP_Terminated()");
4879
4880 #ifdef DTI
4881 #if defined (FF_WAP) || defined (FF_GPF_TCPIP) || defined (FF_SAT_E)
4882 if (Wap_Call EQ TRUE)
4883 {
4884 if(is_gpf_tcpip_call()) {
4885 GPF_TCPIP_STATEMENT(dti_cntrl_entity_disconnected(peer_link_id,
4886 DTI_ENTITY_TCPIP ));
4887 }
4888 else {
4889 dti_cntrl_entity_disconnected( peer_link_id, DTI_ENTITY_IP );
4890 }
4891 dti_cntrl_entity_disconnected( prot_link_id, DTI_ENTITY_L2R );
4892 }
4893 #endif /* WAP || defined (FF_GPF_TCPIP) || SAT E */
4894
4895 dti_cntrl_entity_disconnected( peer_link_id, DTI_ENTITY_PPPC );
4896 dti_cntrl_entity_disconnected( prot_link_id, DTI_ENTITY_PPPC );
4897
4898
4899 #if defined (FF_SAT_E)
4900 if( cmhSAT_OpChnChckCSD(UDP))
4901 {
4902 psaTCPIP_Deactivate(cmhSAT_OpChnUDPDeactCsd) ;
4903 }
4904 else
4905 #endif /* FF_SAT_E */
4906 #if defined (FF_WAP) OR defined (FF_GPF_TCPIP)
4907 {
4908 psaTCPIP_Deactivate(psaTCPIP_deact_csd_callback) ;
4909 }
4910 #endif /* defined (WAP) OR defined (FF_GPF_TCPIP) */
4911 #endif /* DTI */
4912 return 0;
4913 }
4914
4915
4916 #endif /* of WAP or FF_PPP || defined (FF_GPF_TCPIP) or SAT E */
4917
4918 /*
4919 +--------------------------------------------------------------------+
4920 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
4921 | STATE : code ROUTINE : cmhCC_checkALS_Support_cb|
4922 +--------------------------------------------------------------------+
4923
4924 PURPOSE : Call-backs for ALS support check.
4925 */
4926
4927 GLOBAL void cmhCC_checkALS_Support_cb ( SHORT aId )
4928 {
4929 TRACE_FUNCTION ("cmhCC_checkALS_Support_cb()");
4930
4931 simShrdPrm.atb[aId].ntryUsdFlg = FALSE;
4932
4933 /* Step #1: Reading of CPHS Info */
4934 if (simShrdPrm.atb[aId].errCode NEQ SIM_NO_ERROR OR
4935 simShrdPrm.atb[aId].exchData EQ NULL OR
4936 simShrdPrm.atb[aId].dataLen < 2)
4937 {
4938 ; /* CPHS info not supported or invalid */
4939 }
4940 else if ((simShrdPrm.atb[aId].exchData[1] & 0x03) EQ ALLOCATED_AND_ACTIVATED)
4941 {
4942 /* continue with step 2 */
4943 cmhCC_checkALS_Support_2();
4944 return;
4945 }
4946
4947 cmhCC_checkALS_Support_exec( 0 );
4948 }
4949
4950 GLOBAL void cmhCC_checkALS_Support_cb_2 ( SHORT aId )
4951 {
4952 int i;
4953
4954 TRACE_FUNCTION ("cmhCC_checkALS_Support_cb_2()");
4955
4956 simShrdPrm.atb[aId].ntryUsdFlg = FALSE;
4957
4958 if (simShrdPrm.atb[aId].errCode NEQ SIM_NO_ERROR OR
4959 simShrdPrm.atb[aId].exchData EQ NULL OR
4960 simShrdPrm.atb[aId].dataLen < ACI_CPHS_CSP_SIZE )
4961 {
4962 ; /* CSP not supported or invalid */
4963 }
4964 else
4965 {
4966 for (i = 0; i < simShrdPrm.atb[aId].dataLen; i += 2)
4967 {
4968 if (simShrdPrm.atb[aId].exchData[i] EQ ALS_SERVICE_GROUP_CODE)
4969 {
4970 if (BITFIELD_CHECK(simShrdPrm.atb[aId].exchData[i+1],ALS_BIT_ON))
4971 {
4972 cmhCC_checkALS_Support_exec( 1 );
4973 return;
4974 }
4975 break;
4976 }
4977 }
4978 }
4979
4980 cmhCC_checkALS_Support_exec( 0 );
4981 }
4982
4983
4984 GLOBAL void cmhCC_checkALS_Support_exec ( UBYTE flag )
4985 {
4986 T_ACI_CMD_SRC ownBuf; /* buffers current owner */
4987 T_ACI_ALS_MOD ALSmode;
4988
4989 TRACE_FUNCTION ("cmhCC_checkALS_Support_exec()");
4990
4991 ownBuf = simEntStat.entOwn;
4992
4993 simEntStat.curCmd = AT_CMD_NONE;
4994 simShrdPrm.owner = (T_OWN)CMD_SRC_NONE;
4995 simEntStat.entOwn = CMD_SRC_NONE;
4996
4997 switch (ccShrdPrm.als_cmd)
4998 {
4999 case ALS_CMD_SET:
5000 if (flag)
5001 {
5002 cmhPrm[ownBuf].ccCmdPrm.ALSmode = ALS_MOD_AUX_SPEECH;
5003 R_AT( RAT_OK, ownBuf ) ( AT_CMD_ALS );
5004 }
5005 else
5006 {
5007 R_AT( RAT_CME, ownBuf ) ( AT_CMD_ALS, CME_ERR_OpNotSupp );
5008 }
5009 break;
5010 case ALS_CMD_TEST:
5011 if (flag)
5012 {
5013 ALSmode = (T_ACI_ALS_MOD)(ALS_MOD_SPEECH | ALS_MOD_AUX_SPEECH);
5014 }
5015 else
5016 {
5017 ALSmode = ALS_MOD_SPEECH;
5018 }
5019 R_AT( RAT_ALS, ownBuf ) ( ALSmode );
5020 R_AT( RAT_OK, ownBuf ) ( AT_CMD_ALS );
5021 break;
5022 default:
5023 TRACE_EVENT("wrong value in als_cmd");
5024 R_AT( RAT_CME, ownBuf ) ( AT_CMD_ALS, CME_ERR_OpNotSupp );
5025 }
5026 ccShrdPrm.als_cmd = ALS_CMD_NONE;
5027 }
5028
5029 /*
5030 +-------------------------------------------------------------------+
5031 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
5032 | ROUTINE : cmhCC_satTimeout |
5033 +-------------------------------------------------------------------+
5034
5035 PURPOSE : handle redial timeout of SAT max duration
5036
5037 */
5038
5039 GLOBAL void cmhCC_satTimeout( void )
5040 {
5041 TRACE_FUNCTION( "cmhCC_satTimeout()" );
5042 /* Stop the redial timer if still running */
5043 TIMERSTOP (ACI_REPEAT_HND);
5044 /* Send Terminal response to SIM with Network unable to handle error */
5045 cmhSAT_NtwErr( (UBYTE)((GET_CAUSE_VALUE(ccShrdPrm.ctb[rdlPrm.rdlcId]->nrmCs) NEQ NOT_PRESENT_8BIT)?
5046 (ccShrdPrm.ctb[rdlPrm.rdlcId]->nrmCs|0x80) : ADD_NO_CAUSE));
5047 /* Reset the call table */
5048 psaCC_FreeCtbNtry (rdlPrm.rdlcId);
5049 /* Reset the SA maximum duration timer */
5050 satShrdPrm.dur = -1;
5051 } /* End of cmhCC_satTimeout() */
5052
5053
5054 /*
5055 +-------------------------------------------------------------------+
5056 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
5057 | ROUTINE : cmhCC_redialTimeout |
5058 +-------------------------------------------------------------------+
5059
5060 PURPOSE : handle redial timeout
5061
5062 */
5063
5064 GLOBAL void cmhCC_redialTimeout ( void )
5065 {
5066 int i;
5067 T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */
5068 T_SIM_SET_PRM * pSSetPrm; /* points to SIM set parameters */
5069
5070 #ifdef SIM_TOOLKIT
5071 T_ACI_RETURN aciRet;
5072 T_ACI_SAT_TERM_RESP resp_data;
5073 psaSAT_InitTrmResp( &resp_data );
5074 #endif /* SIM_TOOLKIT */
5075
5076 TRACE_FUNCTION( "cmhCC_redialTimeout()" );
5077
5078 #ifdef SIM_TOOLKIT
5079 pSSetPrm = &simShrdPrm.setPrm[ccShrdPrm.ctb[rdlPrm.rdlcId]->curSrc];
5080 /* Check For --Envelope Call Control Always Sent To SIM Bit-- */
5081 if ((ccShrdPrm.ctb[rdlPrm.rdlcId]->SATinv & SAT_REDIAL) AND
5082 (pSSetPrm->STKprof[0] & SAT_TP1_CC_ON_REDIAL))
5083 {
5084 /* Enable Call Control By SIM During AutoRedial */
5085 ccShrdPrm.ctb[rdlPrm.rdlcId]->SATinv |= SAT_REDIAL_ECCBE;
5086 aciRet = cmhSAT_CalCntrlBySIM (rdlPrm.rdlcId);
5087
5088 switch (aciRet)
5089 {
5090 case AT_CMPL:
5091 case AT_FAIL:
5092 /* respond with "Interaction with call control by SIM, permanent" */
5093 resp_data.add_content = ADD_NO_CAUSE;
5094 case AT_BUSY:
5095 /* respond with "Interaction with call control by SIM, temporary" */
5096 psaSAT_SendTrmResp( RSLT_CC_SIM_TMP, &resp_data );
5097 psaCC_FreeCtbNtry (rdlPrm.rdlcId);
5098 return;
5099 /*lint -fallthrough*/
5100 default:
5101 break;
5102 }
5103 }
5104 #endif /* SIM_TOOLKIT */
5105
5106
5107 if (psaCC_ctbIsValid (rdlPrm.rdlcId))
5108 {
5109 pCCCmdPrm = &cmhPrm[psaCC_ctb(rdlPrm.rdlcId)->curSrc].ccCmdPrm;
5110
5111 if (rdlPrm.rdlMod EQ AUTOM_REPEAT_ON)
5112 {
5113 if((psaCC_ctb(rdlPrm.rdlcId)->rdlTimIndex >= 1) AND
5114 (psaCC_ctb(rdlPrm.rdlcId)->rdlTimIndex < 3))
5115 {
5116 #ifdef _SIMULATION_
5117 TIMERSTART(ACI_REPEAT_1,ACI_REPEAT_HND);
5118 #else
5119 psaCC_ctb(rdlPrm.rdlcId)->rdlTimIndex++;
5120 TIMERSTART(ACI_REPEAT_2_4,ACI_REPEAT_HND);
5121 #endif
5122 }
5123 else
5124 {
5125 psaCC_ctb(rdlPrm.rdlcId)->rdlTimIndex = RDL_TIM_INDEX_NOT_PRESENT;
5126 psaCC_ctb(rdlPrm.rdlcId)->rdlCnt++;
5127 for(i = 0; i < CMD_SRC_MAX; i++)
5128 {
5129 R_AT(RAT_RDL,(T_ACI_CMD_SRC)i)(REDIAL_ATT_START);
5130 }
5131 psaCC_ctb(rdlPrm.rdlcId)->calType = CT_MOC_RDL;
5132 cmhCC_flagCall( rdlPrm.rdlcId, &(pCCCmdPrm->mltyCncFlg));
5133 /* start a new call */
5134 psaCC_NewCall(rdlPrm.rdlcId);
5135 rdlPrm.rdlcId = NO_ENTRY;
5136 }
5137 }
5138 else
5139 {
5140 TRACE_EVENT("cmhCC_redialTimeout: wrong cId");
5141 }
5142 }
5143 }
5144
5145
5146 /*
5147 +-------------------------------------------------------------------+
5148 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
5149 | ROUTINE : cmhCC_sendFie |
5150 +-------------------------------------------------------------------+
5151
5152 PURPOSE : forward unsolicited facility responses from CC to terminal
5153
5154 */
5155 GLOBAL T_ACI_RETURN cmhCC_sendFie( T_ACI_FAC_DIR tDirection,
5156 SHORT cId,
5157 T_MNCC_fac_inf *fie )
5158 {
5159 T_ACI_CMD_SRC tSrc;
5160
5161 TRACE_EVENT( "cmhCC_sendFie()" );
5162
5163 for( tSrc=CMD_SRC_LCL; tSrc<CMD_SRC_MAX; tSrc++ ) /* try over all sources */
5164 {
5165 if( cmhPrm[tSrc].ccCmdPrm.CSCNcc_mode.CcCSCNModeState EQ CC_CSCN_MOD_STATE_ON )
5166 {
5167 switch (cmhPrm[tSrc].ccCmdPrm.CSCNcc_mode.CcCSCNModeDirection)
5168 {
5169 case CC_CSCN_MOD_DIR_BOTH:
5170 break; /* printout regardless of direction */
5171
5172 case CC_CSCN_MOD_DIR_IN:
5173 if( tDirection NEQ CSCN_FACILITY_DIRECTION_IN)
5174 continue; /* settings for source don't match, advance to next source */
5175 break;
5176
5177 case CC_CSCN_MOD_DIR_OUT:
5178 if( tDirection NEQ CSCN_FACILITY_DIRECTION_OUT )
5179 continue; /* settings for source don't match, advance to next source */
5180 break;
5181
5182 default:
5183 continue; /* illegal setting, advance to next source */
5184 }
5185 R_AT( RAT_CCCN, tSrc )( tDirection, cId, fie );
5186 }
5187 }
5188 return( AT_CMPL );
5189 }
5190
5191 /*
5192 +-------------------------------------------------------------------+
5193 | PROJECT : GSM-PS (6147) MODULE : CMH_CCR |
5194 | ROUTINE : cmhCC_ChngWaitingToIncoming |
5195 +-------------------------------------------------------------------+
5196
5197 PURPOSE : Change waiting call to incomimg call.
5198
5199 */
5200
5201 GLOBAL void cmhCC_ChngWaitingToIncoming( void )
5202 {
5203 SHORT cId;
5204 /* If there is a call in CS_ACT_REQ state then send ring ind to the src's */
5205 cId = psaCC_ctbFindCall( (T_OWN)CMD_SRC_NONE, CS_ACT_REQ, CT_MTC );
5206 if (cId NEQ NO_ENTRY)
5207 {
5208 if((psaCC_ctb(cId)->calStat EQ CS_ACT_REQ) AND (CHLDaddInfo EQ NO_CHLD_ADD_INFO))
5209 {
5210 cmhCC_IncomingCall(cId); /* There is a call in CS_ACT_REQ state */
5211 }
5212 }
5213 }
5214
5215
5216 /* Implements Measure 184, 185 and 187 */
5217 /*
5218 +------------------------------------------------------------------------------
5219 | Function : cmhCC_tstAndUnflag_MPTYCall
5220 +------------------------------------------------------------------------------
5221 | Purpose : This Function will test and unflag a call for multy-call operation.
5222 |
5223 | Parameters : cId - Call Id.
5224 | srcBuf - Buffers Current Command Source
5225 | cmdBuf - Buffers Current Command
5226 |
5227 | Return : void
5228 +------------------------------------------------------------------------------
5229 */
5230
5231 LOCAL void cmhCC_tstAndUnflag_MPTYCall( SHORT cId, UBYTE srcBuf, UBYTE cmdBuf,
5232 T_CC_CMD_PRM *pCCCmdPrm )
5233 {
5234 TRACE_FUNCTION ("cmhCC_tstAndUnflag_MPTYCall()");
5235
5236 if( cmhCC_tstAndUnflagCall( cId, &(pCCCmdPrm -> mltyCncFlg)))
5237 {
5238 if( pCCCmdPrm -> mltyCncFlg EQ 0 AND
5239 pCCCmdPrm -> mltyDscFlg EQ 0 )
5240 {
5241 R_AT( RAT_OK, (T_ACI_CMD_SRC)srcBuf ) ( cmdBuf );
5242
5243 /* log result */
5244 cmh_logRslt ( (T_ACI_CMD_SRC)srcBuf, RAT_OK,
5245 (T_ACI_AT_CMD)cmdBuf, (SHORT)(cId+1), BS_SPEED_NotPresent,CME_ERR_NotPresent);
5246 }
5247 }
5248 }
5249
5250 /* Implements Measure 32 */
5251 /*
5252 +------------------------------------------------------------------------------
5253 | Function : cmhCC_check_isCallServiced
5254 +------------------------------------------------------------------------------
5255 | Purpose : This Function will check whether the Call was serviced or not.
5256 | If the call was found to be not serviced then add call
5257 | to LMN Phone Book.
5258 |
5259 | Parameters : cId - Call Id.
5260 |
5261 | Return : Returns TRUE if the Call is added to LMN Phone Book.
5262 | Returns FALSE if the Call is not added to LMN Phone Book.
5263 +------------------------------------------------------------------------------
5264 */
5265
5266 LOCAL BOOL cmhCC_check_isCallServiced( SHORT cId )
5267 {
5268 UBYTE idx;
5269 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
5270
5271 TRACE_FUNCTION ("cmhCC_check_isCallServiced()");
5272
5273 if( ctb->calOwn EQ (T_OWN)CMD_SRC_NONE AND
5274 ctb->curCmd EQ AT_CMD_NONE )
5275 {
5276 psaCC_phbAddNtry ( LMN, cId, CT_MTC, NULL ); /* add call to LMN PB */
5277
5278 #ifdef AT_INTERPRETER
5279 /* V.24 Ring Indicator Line */
5280 io_setRngInd (IO_RING_OFF, CRING_SERV_TYP_NotPresent, CRING_SERV_TYP_NotPresent ); /* V.24 Ring Indicator Line */
5281 #endif
5282
5283 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
5284 {
5285 R_AT( RAT_CRING_OFF, (T_ACI_CMD_SRC)idx )( cId+1 );
5286 }
5287 return TRUE;
5288 }
5289 return FALSE;
5290 }
5291
5292 /* Implements Measure 207 */
5293 /*
5294 +------------------------------------------------------------------------------
5295 | Function : cmhCC_Call_Progress_Information
5296 +------------------------------------------------------------------------------
5297 | Purpose : This Function will provide the Information regarding the
5298 | Progress of the call to the User.
5299 |
5300 | Parameters : cId - Call Id.
5301 | msgType - Call Control Message Type
5302 |
5303 | Return : void
5304 |+------------------------------------------------------------------------------
5305 */
5306
5307 LOCAL void cmhCC_Call_Progress_Information( SHORT cId, T_ACI_CPI_MSG msgType, USHORT cause )
5308 {
5309 UBYTE idx;
5310 T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId];
5311
5312 TRACE_FUNCTION ("cmhCC_Call_Progress_Information()");
5313
5314 for( idx = 0; idx < CMD_SRC_MAX; idx++ )
5315 {
5316 R_AT( RAT_CPI, (T_ACI_CMD_SRC)idx )
5317 ( cId+1,
5318 msgType,
5319 (ctb->inBndTns)? CPI_IBT_True: CPI_IBT_False,
5320 (ccShrdPrm.TCHasg)? CPI_TCH_True: CPI_TCH_False,
5321 cause);
5322 }
5323 }
5324
5325 /*==== EOF ========================================================*/
5326