FreeCalypso > hg > freecalypso-citrine
comparison g23m-aci/aci/cmh_ccr.c @ 0:75a11d740a02
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Thu, 09 Jun 2016 00:02:41 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:75a11d740a02 |
---|---|
1 /* | |
2 +----------------------------------------------------------------------------- | |
3 | Project : GSM-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 |