FreeCalypso > hg > freecalypso-citrine
comparison g23m-aci/aci/psa_ccp.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 : PSA_CCP | |
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 processing functions for the | |
18 | primitives send to the protocol stack adapter by call | |
19 | control. | |
20 +----------------------------------------------------------------------------- | |
21 */ | |
22 | |
23 #ifndef PSA_CCP_C | |
24 #define PSA_CCP_C | |
25 #endif | |
26 | |
27 #include "config.h" | |
28 #include "fixedconf.h" | |
29 #include "condat-features.h" | |
30 #include "aci_conf.h" | |
31 | |
32 #include "aci_all.h" | |
33 | |
34 /*==== INCLUDES ===================================================*/ | |
35 #include "ccdapi.h" | |
36 | |
37 #include "aci_cmh.h" | |
38 #include "ati_cmd.h" | |
39 #include "aci_cmd.h" | |
40 #include "aci_mem.h" | |
41 #include "aci_lst.h" | |
42 | |
43 #ifdef FAX_AND_DATA | |
44 #include "aci_fd.h" | |
45 #endif /* of #ifdef FAX_AND_DATA */ | |
46 | |
47 #include "aci.h" | |
48 #include "psa.h" | |
49 #include "psa_cc.h" | |
50 #include "psa_ss.h" | |
51 #include "psa_mmi.h" | |
52 #include "psa_mm.h" | |
53 #include "cmh.h" | |
54 #include "cmh_cc.h" | |
55 | |
56 #ifdef SIM_TOOLKIT | |
57 #include "psa_sat.h" | |
58 #include "cmh_sat.h" | |
59 #endif /* of #ifdef SIM_TOOLKIT */ | |
60 | |
61 #include "aoc.h" | |
62 #include "psa_sim.h" | |
63 | |
64 #if defined (FF_WAP) || defined (FF_SAT_E) | |
65 #include "wap_aci.h" | |
66 #endif /* of FF_WAP */ | |
67 | |
68 #include "l4_tim.h" | |
69 | |
70 /*==== CONSTANTS ==================================================*/ | |
71 | |
72 | |
73 /*==== TYPES ======================================================*/ | |
74 | |
75 | |
76 /*==== EXPORT =====================================================*/ | |
77 | |
78 #ifdef FF_EM_MODE | |
79 EXTERN USHORT em_relcs; | |
80 #endif /* FF_EM_MODE */ | |
81 | |
82 /*==== VARIABLES ==================================================*/ | |
83 | |
84 EXTERN T_PCEER causeMod; | |
85 EXTERN SHORT causeCeer; | |
86 | |
87 /*==== FUNCTIONS ==================================================*/ | |
88 | |
89 | |
90 /* | |
91 +-------------------------------------------------------------------+ | |
92 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
93 | ROUTINE : psa_mncc_setup_ind | | |
94 +-------------------------------------------------------------------+ | |
95 | |
96 PURPOSE : processes the MNCC_SETUP_IND primitive send by CC. | |
97 this indicates an incoming call. | |
98 | |
99 */ | |
100 | |
101 GLOBAL void psa_mncc_setup_ind | |
102 ( T_MNCC_SETUP_IND *mncc_setup_ind ) | |
103 { | |
104 SHORT cId; /* holds call id */ | |
105 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ | |
106 int i; | |
107 | |
108 TRACE_FUNCTION ("psa_mncc_setup_ind()"); | |
109 | |
110 causeMod = P_CEER_mod; /* Clear module which was set for ceer */ | |
111 causeCeer = CEER_NotPresent; /* Clear extended error cause */ | |
112 | |
113 /* stop redialling timer if necessary */ | |
114 if (rdlPrm.rdlcId NEQ NO_ENTRY) | |
115 { | |
116 TIMERSTOP(ACI_REPEAT_HND); | |
117 | |
118 #ifdef SIM_TOOLKIT | |
119 if( ( ccShrdPrm.ctb[rdlPrm.rdlcId]->SATinv & SAT_REDIAL ) ) | |
120 { /* This is the call invoked by SAT */ | |
121 T_ACI_SAT_TERM_RESP resp_data; | |
122 | |
123 psaSAT_InitTrmResp( &resp_data ); | |
124 psaSAT_SendTrmResp( RSLT_USR_CLR_DWN, &resp_data ); | |
125 } | |
126 #endif /* SIM_TOOLKIT */ | |
127 | |
128 psaCC_FreeCtbNtry (rdlPrm.rdlcId); | |
129 for(i = 0; i < CMD_SRC_MAX; i++) | |
130 { | |
131 R_AT(RAT_RDL, (T_ACI_CMD_SRC)i)(REDIAL_STOP); | |
132 } | |
133 /* reset some redial parameter */ | |
134 rdlPrm.rdlcId = NO_ENTRY; | |
135 } | |
136 | |
137 /* | |
138 *------------------------------------------------------------------- | |
139 * check for new entry in call table | |
140 *------------------------------------------------------------------- | |
141 */ | |
142 cId = psaCC_ctbNewEntry(); | |
143 | |
144 if( cId < 0 ) | |
145 { | |
146 /* | |
147 * disconnect call, due to full call table. | |
148 */ | |
149 { | |
150 UBYTE ti = mncc_setup_ind -> ti; | |
151 PREUSE (mncc_setup_ind, mncc_disconnect_req, MNCC_DISCONNECT_REQ); | |
152 mncc_disconnect_req -> ti = ti; | |
153 mncc_disconnect_req -> cause = MNCC_CAUSE_USER_BUSY; | |
154 mncc_disconnect_req -> fac_inf.l_fac = 0; | |
155 mncc_disconnect_req -> ss_version = MNCC_SS_VER_NOT_PRES; | |
156 PSENDX (CC, mncc_disconnect_req); | |
157 } | |
158 | |
159 TRACE_EVENT ("MTC rejected due to full call table"); | |
160 | |
161 return; | |
162 } | |
163 | |
164 /* | |
165 *------------------------------------------------------------------- | |
166 * update shared parameter and notify ACI | |
167 *------------------------------------------------------------------- | |
168 */ | |
169 pCtbNtry = ccShrdPrm.ctb[cId]; | |
170 pCtbNtry -> curCs = MNCC_CAUSE_NO_MS_CAUSE; | |
171 | |
172 pCtbNtry -> ti = mncc_setup_ind -> ti; | |
173 pCtbNtry -> rptInd = mncc_setup_ind -> ri; | |
174 pCtbNtry -> sigInf = mncc_setup_ind -> sig; | |
175 pCtbNtry -> clgPty = mncc_setup_ind -> calling_party; | |
176 pCtbNtry -> clgPtySub = mncc_setup_ind -> calling_party_sub; | |
177 | |
178 /* | |
179 * Assign called party | |
180 */ | |
181 pCtbNtry -> cldPty.ton = mncc_setup_ind -> called_party.ton; | |
182 pCtbNtry -> cldPty.npi = mncc_setup_ind -> called_party.npi; | |
183 pCtbNtry -> cldPty.c_called_num = | |
184 mncc_setup_ind -> called_party.c_called_num; | |
185 if (pCtbNtry -> cldPty.called_num NEQ NULL) | |
186 { | |
187 ACI_MFREE (pCtbNtry -> cldPty.called_num); | |
188 pCtbNtry -> cldPty.called_num = NULL; | |
189 } | |
190 if (pCtbNtry -> cldPty.c_called_num NEQ 0) | |
191 { | |
192 ACI_MALLOC (pCtbNtry -> cldPty.called_num, | |
193 pCtbNtry -> cldPty.c_called_num); | |
194 memcpy (pCtbNtry -> cldPty.called_num, | |
195 mncc_setup_ind -> called_party.called_num, | |
196 mncc_setup_ind -> called_party.c_called_num); | |
197 } | |
198 | |
199 /* | |
200 * Assign called party subaddress | |
201 */ | |
202 pCtbNtry -> cldPtySub = mncc_setup_ind -> called_party_sub; | |
203 | |
204 /* | |
205 * Assign redirecting party | |
206 */ | |
207 pCtbNtry -> rdrPty.ton = mncc_setup_ind -> redirecting_party.ton; | |
208 pCtbNtry -> rdrPty.npi = mncc_setup_ind -> redirecting_party.npi; | |
209 pCtbNtry -> rdrPty.present = mncc_setup_ind -> redirecting_party.present; | |
210 pCtbNtry -> rdrPty.screen = mncc_setup_ind -> redirecting_party.screen; | |
211 pCtbNtry -> rdrPty.c_redir_num = | |
212 mncc_setup_ind -> redirecting_party.c_redir_num; | |
213 if (pCtbNtry -> rdrPty.redir_num NEQ NULL) | |
214 { | |
215 ACI_MFREE (pCtbNtry -> rdrPty.redir_num); | |
216 pCtbNtry -> rdrPty.redir_num = NULL; | |
217 } | |
218 if (pCtbNtry -> rdrPty.c_redir_num NEQ 0) | |
219 { | |
220 ACI_MALLOC (pCtbNtry -> rdrPty.redir_num, | |
221 pCtbNtry -> rdrPty.c_redir_num); | |
222 memcpy (pCtbNtry -> rdrPty.redir_num, | |
223 mncc_setup_ind -> redirecting_party.redir_num, | |
224 mncc_setup_ind -> redirecting_party.c_redir_num); | |
225 } | |
226 | |
227 /* | |
228 * Assign redirecting party subaddress | |
229 */ | |
230 pCtbNtry -> rdrPtySub.tos = | |
231 mncc_setup_ind -> redirecting_party_sub.tos; | |
232 pCtbNtry -> rdrPtySub.odd_even = | |
233 mncc_setup_ind -> redirecting_party_sub.odd_even; | |
234 pCtbNtry -> rdrPtySub.c_subaddr = | |
235 mncc_setup_ind -> redirecting_party_sub.c_subaddr; | |
236 if (pCtbNtry -> rdrPtySub.subaddr NEQ NULL) | |
237 { | |
238 ACI_MFREE (pCtbNtry -> rdrPtySub.subaddr); | |
239 pCtbNtry -> rdrPtySub.subaddr = NULL; | |
240 } | |
241 if (pCtbNtry -> rdrPtySub.c_subaddr NEQ 0) | |
242 { | |
243 ACI_MALLOC (pCtbNtry -> rdrPtySub.subaddr, | |
244 pCtbNtry -> rdrPtySub.c_subaddr); | |
245 memcpy (pCtbNtry -> rdrPtySub.subaddr, | |
246 mncc_setup_ind -> redirecting_party_sub.subaddr, | |
247 mncc_setup_ind -> redirecting_party_sub.c_subaddr); | |
248 } | |
249 | |
250 /* | |
251 * Assign bearer caps | |
252 */ | |
253 memcpy( &(pCtbNtry->BC[0]),&(mncc_setup_ind->bcpara), | |
254 sizeof( T_MNCC_bcpara) ); | |
255 memcpy( &(pCtbNtry->BC[1]),&(mncc_setup_ind->bcpara2), | |
256 sizeof( T_MNCC_bcpara) ); | |
257 | |
258 psaCC_phbSrchNum( cId, CT_MTC ); | |
259 | |
260 pCtbNtry -> calStat = CS_ACT_REQ; | |
261 pCtbNtry -> calType = CT_MTC; | |
262 | |
263 pCtbNtry -> prio = MNCC_PRIO_NORM_CALL; | |
264 pCtbNtry -> curBC = 0; | |
265 | |
266 psaCC_send_satevent( EVENT_MT_CALL, cId, FAR_END, FALSE ); | |
267 | |
268 /* | |
269 *------------------------------------------------------------------- | |
270 * indicate alerting | |
271 *------------------------------------------------------------------- | |
272 */ | |
273 | |
274 /* replace invalid/unknown sigInf by SIG_NOT_PRES */ | |
275 switch (pCtbNtry -> sigInf) | |
276 { | |
277 case MNCC_SIG_DIAL_TONE_ON: | |
278 case MNCC_SIG_RING_BACK_TONE_ON: | |
279 case MNCC_SIG_INT_TONE_ON: | |
280 case MNCC_SIG_NET_CONG_TONE_ON: | |
281 case MNCC_SIG_BUSY_TONE_ON: | |
282 case MNCC_SIG_CONF_TONE_ON: | |
283 case MNCC_SIG_ANS_TONE_ON: | |
284 case MNCC_SIG_CALL_WAIT_TONE_ON: | |
285 case MNCC_SIG_OFF_HOOK_WARN_TONE_ON: | |
286 case MNCC_SIG_TONES_OFF: | |
287 case MNCC_SIG_ALERT_OFF: | |
288 case MNCC_SIG_NOT_PRES: | |
289 break; /* leave as it is */ | |
290 default: /* replace unknown value by something well known */ | |
291 pCtbNtry -> sigInf = MNCC_SIG_NOT_PRES; | |
292 } | |
293 | |
294 if( pCtbNtry -> sigInf NEQ MNCC_SIG_NOT_PRES OR | |
295 ccShrdPrm.TCHasg EQ TRUE ) | |
296 { | |
297 { | |
298 /* indicate alerting to network */ | |
299 UBYTE ti = mncc_setup_ind -> ti; | |
300 PREUSE (mncc_setup_ind, mncc_alert_req, MNCC_ALERT_REQ); | |
301 mncc_alert_req -> ti = ti; | |
302 PSENDX (CC, mncc_alert_req); | |
303 } | |
304 | |
305 cmhCC_IncomingCall (cId); /* indicate an incoming call */ | |
306 return; | |
307 } | |
308 else | |
309 { | |
310 pCtbNtry -> alrtStat = AS_PND; | |
311 } | |
312 | |
313 /* | |
314 * check for progress descriptions | |
315 */ | |
316 psaCC_chkPrgDesc ( cId, mncc_setup_ind -> progress_desc, MT_SETUP ); | |
317 | |
318 /* | |
319 * start call time measurements | |
320 */ | |
321 aoc_info (cId, AOC_START_TIME); | |
322 /* | |
323 *------------------------------------------------------------------- | |
324 * free the primitive buffer | |
325 *------------------------------------------------------------------- | |
326 */ | |
327 PFREE (mncc_setup_ind); | |
328 } | |
329 | |
330 /* | |
331 +-------------------------------------------------------------------+ | |
332 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
333 | ROUTINE : psa_mncc_setup_cnf | | |
334 +-------------------------------------------------------------------+ | |
335 | |
336 PURPOSE : processes the MNCC_SETUP_CNF primitive send by CC. | |
337 this terminates the call establishment request. | |
338 | |
339 */ | |
340 | |
341 GLOBAL void psa_mncc_setup_cnf | |
342 ( T_MNCC_SETUP_CNF *mncc_setup_cnf ) | |
343 { | |
344 SHORT cId; /* holds call id */ | |
345 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ | |
346 int i; | |
347 BOOL flag_redial = FALSE; | |
348 | |
349 TRACE_FUNCTION ("psa_mncc_setup_cnf()"); | |
350 | |
351 /* | |
352 *------------------------------------------------------------------- | |
353 * find call in call table | |
354 *------------------------------------------------------------------- | |
355 */ | |
356 cId = psaCC_ctbFindTi( mncc_setup_cnf -> ti ); | |
357 | |
358 if( cId < 0 ) | |
359 { | |
360 /* | |
361 * ignore primitive, due to not found transaction identifier. | |
362 */ | |
363 TRACE_EVENT ("primitive rejected due to unused ti"); | |
364 PFREE(mncc_setup_cnf); | |
365 return; | |
366 } | |
367 | |
368 /* | |
369 *------------------------------------------------------------------- | |
370 * update shared parameter and notify ACI | |
371 *------------------------------------------------------------------- | |
372 */ | |
373 pCtbNtry = ccShrdPrm.ctb[cId]; | |
374 pCtbNtry -> curCs = mncc_setup_cnf -> cause; | |
375 pCtbNtry -> rslt = mncc_setup_cnf -> cause; | |
376 | |
377 | |
378 switch( mncc_setup_cnf -> cause ) | |
379 { | |
380 case( MNCC_CAUSE_SUCCESS ): /* successful establishment, call connected */ | |
381 | |
382 /* | |
383 * MNCC_SETUP_CNF is received in call state other than CS_ACT_REQ | |
384 * so reject the primitive. | |
385 */ | |
386 if( pCtbNtry -> calStat NEQ CS_ACT_REQ) | |
387 { | |
388 TRACE_EVENT ("MNCC_SETUP_CNF is rejected as it is received in call state other than CS_ACT_REQ"); | |
389 break; | |
390 } | |
391 pCtbNtry -> clgPty.ton = mncc_setup_cnf -> connected_number.ton; | |
392 pCtbNtry -> clgPty.npi = mncc_setup_cnf -> connected_number.npi; | |
393 pCtbNtry -> clgPty.present = mncc_setup_cnf -> connected_number.present; | |
394 pCtbNtry -> clgPty.screen = mncc_setup_cnf -> connected_number.screen; | |
395 pCtbNtry -> clgPty.c_num = mncc_setup_cnf -> connected_number.c_num; | |
396 | |
397 memcpy( pCtbNtry -> clgPty.num, | |
398 mncc_setup_cnf -> connected_number.num, MNCC_MAX_CC_CALLING_NUMBER ); | |
399 | |
400 pCtbNtry -> clgPtySub.tos = mncc_setup_cnf -> connected_number_sub.tos; | |
401 pCtbNtry -> clgPtySub.odd_even = mncc_setup_cnf -> connected_number_sub.odd_even; | |
402 pCtbNtry -> clgPtySub.c_subaddr = mncc_setup_cnf -> connected_number_sub.c_subaddr; | |
403 | |
404 memcpy( pCtbNtry -> clgPtySub.subaddr, | |
405 mncc_setup_cnf -> connected_number_sub.subaddr, MNCC_SUB_LENGTH ); | |
406 | |
407 pCtbNtry -> inBndTns = FALSE; | |
408 pCtbNtry -> calStat = CS_ACT; | |
409 | |
410 /* check for progress descriptions */ | |
411 psaCC_chkPrgDesc ( cId, mncc_setup_cnf -> progress_desc, MT_CONN ); | |
412 | |
413 | |
414 if(pCtbNtry->calType EQ CT_MOC_RDL) | |
415 { | |
416 pCtbNtry->calType = CT_MOC; | |
417 flag_redial = TRUE; | |
418 } | |
419 /* if redialling procedure was successful we finish redialling */ | |
420 if((rdlPrm.rdlMod EQ AUTOM_REPEAT_ON) AND flag_redial) | |
421 { | |
422 for(i = 0; i < CMD_SRC_MAX; i++) | |
423 { | |
424 R_AT(RAT_RDL, (T_ACI_CMD_SRC)i)(CALL_ATTEMPT_SUCCESSFUL); | |
425 } | |
426 pCtbNtry->rdlCnt = 0; | |
427 rdlPrm.rdlcId = NO_ENTRY; | |
428 pCtbNtry->rdlTimIndex = RDL_TIM_INDEX_NOT_PRESENT; | |
429 flag_redial = FALSE; | |
430 /* Once we stop the redialling procedure | |
431 * We ahev to stop as well the SAT max | |
432 * duration timer (satshrdprm.dur) | |
433 */ | |
434 #ifdef SIM_TOOLKIT | |
435 if(satShrdPrm.ownSAT) | |
436 { | |
437 TIMERSTOP(ACI_SAT_MAX_DUR_HND); | |
438 satShrdPrm.dur = -1; | |
439 } | |
440 #endif /* SIM_TOOLKIT */ | |
441 } | |
442 | |
443 /* | |
444 * The MO call count is increment in MNCC_SETUP_REQ | |
445 * psaCC_chngCalTypCnt( cId, +1 ); | |
446 */ | |
447 | |
448 cmhCC_CallConnected( cId ); | |
449 | |
450 psaCC_send_satevent( EVENT_CALL_CONN, cId, FAR_END, FALSE ); | |
451 | |
452 aoc_info (cId,AOC_CALL_CONNECTED); | |
453 | |
454 /* check for TTY service */ | |
455 cmhCC_TTY_Control ( cId, TTY_START ); | |
456 | |
457 /* check for DTMF tones to send automatically */ | |
458 psaCC_DTMFSent ( cId ); | |
459 | |
460 #if defined (FF_WAP) || defined (FF_SAT_E) | |
461 /* WAP STACK CALL is activ */ | |
462 if (Wap_Call) | |
463 ccShrdPrm.wapStat = CC_WAP_STACK_UP; | |
464 #endif | |
465 | |
466 break; | |
467 | |
468 default: /* unexpected result, assumed call disconnected */ | |
469 { | |
470 TRACE_EVENT_P1("[ERR] UNEXP CAUSE IN SETUP CNF=%4x", mncc_setup_cnf -> cause); | |
471 } | |
472 /*FALLTHROUGH*/ /*lint -fallthrough*/ | |
473 | |
474 /* unsuccessful establishment, call disconnected */ | |
475 case( MNCC_CAUSE_MS_TIMER ): | |
476 | |
477 pCtbNtry -> nrmCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); | |
478 pCtbNtry -> rejCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); | |
479 #ifdef FF_EM_MODE | |
480 em_relcs = MNCC_CAUSE_MS_TIMER; | |
481 #endif /* FF_EM_MODE */ | |
482 ccShrdPrm.cIdFail = cId; | |
483 | |
484 /* | |
485 * At this point the call has not yet gone completely always. | |
486 * Call Control may not be in state U0, but in state U11, having | |
487 * sent a DISCONNECT to the network, expecting the RELEASE | |
488 * from the network or expiry of T308 in CC. | |
489 * Implementation works, but it is not very nice here, releasing | |
490 * the ti and decrementing the call count too early. | |
491 */ | |
492 pCtbNtry -> calStat = CS_IDL; | |
493 | |
494 psaCC_chngCalTypCnt( cId, -1 ); | |
495 psaCC_retMOCTi( pCtbNtry -> ti ); | |
496 cmhCC_CallDisconnected (cId); | |
497 //TISH, patch for OMAPS00129162 | |
498 //Don't free the ti here, MMI will receive release_ind later and release the ti there. | |
499 //start | |
500 // psaCC_FreeCtbNtry (cId); | |
501 //end | |
502 break; | |
503 } | |
504 /* | |
505 *------------------------------------------------------------------- | |
506 * free the primitive buffer | |
507 *------------------------------------------------------------------- | |
508 */ | |
509 PFREE (mncc_setup_cnf); | |
510 | |
511 } | |
512 | |
513 /* | |
514 +-------------------------------------------------------------------+ | |
515 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
516 | ROUTINE : psa_mncc_setup_compl_ind| | |
517 +-------------------------------------------------------------------+ | |
518 | |
519 PURPOSE : processes the MNCC_SETUP_COMPL_IND primitive send by CC. | |
520 this terminates the call establishment of an incoming call. | |
521 | |
522 */ | |
523 | |
524 GLOBAL void psa_mncc_setup_compl_ind | |
525 ( T_MNCC_SETUP_COMPL_IND *mncc_setup_compl_ind ) | |
526 { | |
527 SHORT cId; /* holds call id */ | |
528 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ | |
529 | |
530 TRACE_FUNCTION ("psa_mncc_setup_compl_ind()"); | |
531 | |
532 /* | |
533 *------------------------------------------------------------------- | |
534 * find call in call table | |
535 *------------------------------------------------------------------- | |
536 */ | |
537 cId = psaCC_ctbFindTi( mncc_setup_compl_ind -> ti ); | |
538 | |
539 if( cId < 0 ) | |
540 { | |
541 /* | |
542 * ignore primitive, due to not found transaction identifier. | |
543 */ | |
544 TRACE_EVENT ("primitive rejected due to unused ti"); | |
545 PFREE(mncc_setup_compl_ind); | |
546 return; | |
547 } | |
548 | |
549 /* | |
550 *------------------------------------------------------------------- | |
551 * update shared parameter and notify ACI | |
552 *------------------------------------------------------------------- | |
553 */ | |
554 pCtbNtry = ccShrdPrm.ctb[cId]; | |
555 | |
556 pCtbNtry -> rslt = mncc_setup_compl_ind -> cause; | |
557 pCtbNtry -> curCs = mncc_setup_compl_ind -> cause; | |
558 | |
559 switch( mncc_setup_compl_ind -> cause ) | |
560 { | |
561 case( MNCC_CAUSE_SUCCESS ): /* successful establishment, call connected */ | |
562 | |
563 pCtbNtry -> inBndTns = FALSE; | |
564 pCtbNtry -> calStat = CS_ACT; | |
565 | |
566 psaCC_setSpeechMode (); | |
567 | |
568 /* check for TTY service */ | |
569 cmhCC_TTY_Control ( cId, TTY_START ); | |
570 | |
571 /* | |
572 * Inform that a call goes to active state | |
573 */ | |
574 psaCC_chngCalTypCnt( cId, +1 ); | |
575 | |
576 cmhCC_CallConnected( cId ); | |
577 | |
578 aoc_info (cId, AOC_CALL_CONNECTED); | |
579 break; | |
580 | |
581 default: /* unexpected result, assumed call disconnected */ | |
582 { | |
583 TRACE_EVENT_P1("[ERR] UNEXP CAUSE IN SETUP CMPL IND=%4x", mncc_setup_compl_ind -> cause); | |
584 } | |
585 /*FALLTHROUGH*/ /*lint -fallthrough*/ | |
586 | |
587 /* unsuccessful establishment, call disconnected */ | |
588 case( MNCC_CAUSE_MS_TIMER ): | |
589 | |
590 pCtbNtry -> nrmCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); | |
591 pCtbNtry -> rejCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); | |
592 #ifdef FF_EM_MODE | |
593 em_relcs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); | |
594 #endif /* FF_EM_MODE */ | |
595 ccShrdPrm.cIdFail = cId; | |
596 | |
597 /* | |
598 * What happens below is somewhat questionable. | |
599 * ACI sets the call to CS_IDL and free the transaction identifier. | |
600 * What happened is that on CC level, in state U8 CONNECT REQUEST the | |
601 * CONNECT message sent by CC has not been answered by the network by a | |
602 * CONNECT ACNOWLEDGE message. | |
603 * In this situation CC sends a DISCONNECT to the network and enters | |
604 * state U11 DISCONNECT REQUEST. This means, the call state in CC is | |
605 * still different from U0 NULL. | |
606 * However, problems in the field are not expected here. | |
607 */ | |
608 pCtbNtry -> calStat = CS_IDL; | |
609 | |
610 psaCC_chngCalTypCnt( cId, -1 ); | |
611 psaCC_retMOCTi( pCtbNtry -> ti ); | |
612 | |
613 cmhCC_CallDisconnected (cId); | |
614 cmhCC_CallReleased (cId); | |
615 | |
616 break; | |
617 } | |
618 | |
619 /* | |
620 *------------------------------------------------------------------- | |
621 * free the primitive buffer | |
622 *------------------------------------------------------------------- | |
623 */ | |
624 PFREE (mncc_setup_compl_ind); | |
625 | |
626 } | |
627 | |
628 /* | |
629 +-------------------------------------------------------------------+ | |
630 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
631 | ROUTINE : psa_mncc_reject_ind | | |
632 +-------------------------------------------------------------------+ | |
633 | |
634 PURPOSE : processes the MNCC_REJECT_IND primitive send by CC. | |
635 this indicates a cause for rejecting a call establishment. | |
636 | |
637 */ | |
638 | |
639 GLOBAL void psa_mncc_reject_ind | |
640 ( T_MNCC_REJECT_IND *mncc_reject_ind ) | |
641 { | |
642 SHORT cId; /* holds call id */ | |
643 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ | |
644 | |
645 TRACE_FUNCTION ("psa_mncc_reject_ind()"); | |
646 | |
647 /* | |
648 *------------------------------------------------------------------- | |
649 * find call in call table | |
650 *------------------------------------------------------------------- | |
651 */ | |
652 cId = psaCC_ctbFindTi( mncc_reject_ind -> ti ); | |
653 | |
654 if( cId < 0 ) | |
655 { | |
656 /* | |
657 * ignore primitive, due to not found transaction identifier. | |
658 */ | |
659 TRACE_EVENT ("primitive rejected due to unused ti"); | |
660 PFREE(mncc_reject_ind); | |
661 return; | |
662 } | |
663 psaCC_StopDTMF (cId); /* HM 27.07.00*/ | |
664 | |
665 /* | |
666 *------------------------------------------------------------------- | |
667 * update shared parameter and notify ACI | |
668 *------------------------------------------------------------------- | |
669 */ | |
670 pCtbNtry = ccShrdPrm.ctb[cId]; | |
671 pCtbNtry -> curCs = mncc_reject_ind -> cause; | |
672 | |
673 pCtbNtry -> rslt = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); | |
674 pCtbNtry -> nrmCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); | |
675 pCtbNtry -> rejCs = mncc_reject_ind -> cause; | |
676 /* In this case, the cause values are internal and not sent by network */ | |
677 pCtbNtry -> numRawCauseBytes = 0; | |
678 | |
679 #ifdef FF_EM_MODE | |
680 em_relcs = mncc_reject_ind -> cause; | |
681 #endif /* FF_EM_MODE */ | |
682 | |
683 if( GET_CAUSE_VALUE(pCtbNtry -> rejCs) NEQ NOT_PRESENT_8BIT ) ccShrdPrm.cIdFail = cId; | |
684 | |
685 pCtbNtry -> calStat = CS_IDL; | |
686 | |
687 psaCC_chngCalTypCnt( cId, -1 ); | |
688 psaCC_retMOCTi( pCtbNtry -> ti ); | |
689 | |
690 /* monitoring for SAT radio-link failure */ | |
691 psaCC_send_satevent( EVENT_CALL_DISC, cId, NEAR_END, TRUE ); | |
692 | |
693 /* check conditions for redialling */ | |
694 cmhCC_redialCheck(cId); | |
695 | |
696 #ifdef SIM_TOOLKIT | |
697 if( pCtbNtry->SATinv ) | |
698 { | |
699 cmhSAT_NtwErr( ADD_NO_CAUSE ); | |
700 pCtbNtry->SATinv = FALSE; | |
701 } | |
702 #endif | |
703 /* cmhCC_CallDisconnected(cId);*/ | |
704 cmhCC_CPIrejectMsg(cId); | |
705 cmhCC_CallReleased(cId); | |
706 cmhCC_ChngWaitingToIncoming(); | |
707 | |
708 /* free the primitive buffer */ | |
709 PFREE (mncc_reject_ind); | |
710 | |
711 } | |
712 | |
713 /* | |
714 +-------------------------------------------------------------------+ | |
715 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
716 | ROUTINE : psa_mncc_release_ind | | |
717 +-------------------------------------------------------------------+ | |
718 | |
719 PURPOSE : processes the MNCC_RELEASE_IND primitive send by CC. | |
720 this indicates the release of a call. | |
721 | |
722 */ | |
723 | |
724 GLOBAL void psa_mncc_release_ind | |
725 ( T_MNCC_RELEASE_IND *mncc_release_ind ) | |
726 { | |
727 SHORT cId; /* holds call id */ | |
728 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ | |
729 | |
730 TRACE_FUNCTION ("psa_mncc_release_ind()"); | |
731 | |
732 /* | |
733 *------------------------------------------------------------------- | |
734 * find call in call table | |
735 *------------------------------------------------------------------- | |
736 */ | |
737 cId = psaCC_ctbFindTi( mncc_release_ind -> ti ); | |
738 | |
739 | |
740 if( cId < 0 ) | |
741 { | |
742 psaCC_retMOCTi( mncc_release_ind -> ti ); | |
743 | |
744 /* | |
745 * ignore primitive, due to not found transaction identifier. | |
746 */ | |
747 TRACE_EVENT ("primitive rejected due to unused ti"); | |
748 PFREE(mncc_release_ind); | |
749 return; | |
750 } | |
751 psaCC_StopDTMF ( cId ); /* HM 27.07.00 */ | |
752 | |
753 /* | |
754 *------------------------------------------------------------------- | |
755 * update shared parameter and notify ACI | |
756 *------------------------------------------------------------------- | |
757 */ | |
758 pCtbNtry = ccShrdPrm.ctb[cId]; | |
759 | |
760 pCtbNtry -> calStat = CS_DSC_REQ; /* Leave active state */ | |
761 pCtbNtry -> curCs = mncc_release_ind -> cause; | |
762 pCtbNtry -> numRawCauseBytes = mncc_release_ind -> c_raw_cause; | |
763 pCtbNtry -> rawCauseBytes = mncc_release_ind -> raw_cause; | |
764 | |
765 psaCC_setSpeechMode (); | |
766 | |
767 /* check for TTY service */ | |
768 /*cmhCC_TTY_Control ( cId );*/ | |
769 | |
770 if (pCtbNtry -> nrmCs EQ MNCC_CAUSE_NO_MS_CAUSE) /* no Disconnect Cause available...*/ | |
771 { | |
772 pCtbNtry -> nrmCs= mncc_release_ind -> cause; /* Check ### */ | |
773 ccShrdPrm.cIdFail = cId; /* Check ### */ | |
774 #ifdef FF_EM_MODE | |
775 em_relcs = mncc_release_ind -> cause; /* Check ### */ | |
776 #endif /* FF_EM_MODE */ | |
777 } | |
778 | |
779 pCtbNtry -> rejCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); | |
780 pCtbNtry -> rslt = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); | |
781 | |
782 psaCC_chngCalTypCnt( cId, -1 ); | |
783 psaCC_retMOCTi( pCtbNtry -> ti ); | |
784 | |
785 psaCC_send_satevent( EVENT_CALL_DISC, cId, FAR_END, TRUE ); | |
786 | |
787 pCtbNtry -> numRawCauseBytes = 0; /* Reset the cause value after sending the info to SAT */ | |
788 | |
789 cmhCC_redialCheck(cId); | |
790 | |
791 /* | |
792 if( pCtbNtry -> CCBSstat EQ CCBSS_PSSBL OR | |
793 pCtbNtry -> calType EQ CT_NI_MOC ) | |
794 */ | |
795 switch (pCtbNtry->curCmd) | |
796 { | |
797 case( AT_CMD_A ): | |
798 case( AT_CMD_D ): | |
799 case( AT_CMD_NONE ): | |
800 case( AT_CMD_ABRT ): | |
801 { | |
802 cmhCC_CallDisconnected(cId); | |
803 cmhCC_CallReleased( cId ); | |
804 } | |
805 break; | |
806 | |
807 case( AT_CMD_H ): | |
808 case( AT_CMD_Z ): | |
809 case( AT_CMD_CHUP ): | |
810 case( AT_CMD_CHLD ): | |
811 | |
812 #ifdef FF_FAX | |
813 case( AT_CMD_FKS ): | |
814 case( AT_CMD_FDT ): | |
815 case( AT_CMD_FDR ): | |
816 #endif | |
817 { | |
818 cmhCC_CallDisconnected(cId); | |
819 cmhCC_CPIReleaseMsg(cId); | |
820 } | |
821 break; | |
822 } | |
823 | |
824 if (rdlPrm.rdlcId NEQ cId) | |
825 {/* if redialling is active no clean cId entry */ | |
826 /*patch BE 30.06.00 to remove every other call drops*/ | |
827 psaCC_FreeCtbNtry (cId); | |
828 /*end patch BE */ | |
829 } | |
830 cmhCC_ChngWaitingToIncoming(); | |
831 /* free the primitive buffer */ | |
832 PFREE (mncc_release_ind); | |
833 | |
834 } | |
835 | |
836 /* | |
837 +-------------------------------------------------------------------+ | |
838 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
839 | ROUTINE : psa_mncc_release_cnf | | |
840 +-------------------------------------------------------------------+ | |
841 | |
842 PURPOSE : processes the MNCC_RELEASE_CNF primitive send by CC. | |
843 this confirmates the release request for a call. | |
844 | |
845 */ | |
846 | |
847 GLOBAL void psa_mncc_release_cnf | |
848 ( T_MNCC_RELEASE_CNF *mncc_release_cnf ) | |
849 { | |
850 SHORT cId; /* holds call id */ | |
851 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ | |
852 | |
853 TRACE_FUNCTION ("psa_mncc_release_cnf()"); | |
854 | |
855 /* | |
856 *------------------------------------------------------------------- | |
857 * find call in call table | |
858 *------------------------------------------------------------------- | |
859 */ | |
860 cId = psaCC_ctbFindTi( mncc_release_cnf -> ti ); | |
861 | |
862 if( cId < 0 ) | |
863 { | |
864 psaCC_retMOCTi( mncc_release_cnf -> ti ); | |
865 | |
866 /* | |
867 * ignore primitive, due to not found transaction identifier. | |
868 */ | |
869 TRACE_EVENT ("primitive rejected due to unused ti"); | |
870 PFREE(mncc_release_cnf); | |
871 return; | |
872 } | |
873 | |
874 /* | |
875 *------------------------------------------------------------------- | |
876 * update shared parameter and notify ACI | |
877 *------------------------------------------------------------------- | |
878 */ | |
879 pCtbNtry = ccShrdPrm.ctb[cId]; | |
880 | |
881 /* HM 02-Aug-2002, done while merging SBK code, check again this code*/ | |
882 #if 0 /* Old code */ | |
883 if( mncc_release_cnf -> cause NEQ CAUSE_NOT_PRES ) | |
884 { | |
885 pCtbNtry -> nrmCs = mncc_release_cnf -> cause; | |
886 ccShrdPrm.cIdFail = cId; | |
887 #ifdef FF_EM_MODE | |
888 em_relcs = mncc_release_cnf -> cause; | |
889 #endif /* FF_EM_MODE */ | |
890 } | |
891 #endif /* #if 0 */ | |
892 | |
893 if (pCtbNtry -> nrmCs EQ MNCC_CAUSE_NO_MS_CAUSE) /* no Disconnect Cause available...*/ | |
894 { | |
895 pCtbNtry -> nrmCs = mncc_release_cnf -> cause; /* Recheck ###*/ | |
896 ccShrdPrm.cIdFail = cId; /* This line is considered harmful, only if cause present ### */ | |
897 #ifdef FF_EM_MODE | |
898 em_relcs = mncc_release_cnf -> cause; /* Recheck ### */ | |
899 #endif /* FF_EM_MODE */ | |
900 } | |
901 pCtbNtry -> rslt = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); | |
902 pCtbNtry -> rejCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); | |
903 pCtbNtry -> curCs = pCtbNtry -> rejCs; | |
904 pCtbNtry -> numRawCauseBytes = mncc_release_cnf -> c_raw_cause; | |
905 pCtbNtry -> rawCauseBytes = mncc_release_cnf -> raw_cause; | |
906 #ifdef SIM_TOOLKIT | |
907 if(!(pCtbNtry -> SATinv & SAT_REDIAL)) | |
908 #endif | |
909 pCtbNtry -> calStat = CS_IDL; | |
910 | |
911 psaCC_chngCalTypCnt( cId, -1 ); | |
912 psaCC_retMOCTi( pCtbNtry -> ti ); | |
913 | |
914 psaCC_send_satevent( EVENT_CALL_DISC, cId , FAR_END, TRUE ); | |
915 | |
916 pCtbNtry -> numRawCauseBytes = 0; /* Reset the cause value after sending the info to SAT */ | |
917 | |
918 cmhCC_redialCheck( cId); | |
919 | |
920 cmhCC_CallReleased (cId); | |
921 | |
922 /*patch BE 30.06.00 to remove every other call drops */ | |
923 { | |
924 #ifdef SIM_TOOLKIT | |
925 if ( (pCtbNtry -> SATinv & SAT_REDIAL) EQ 0 ) | |
926 { | |
927 #endif /* SIM_TOOLKIT */ | |
928 if (rdlPrm.rdlcId NEQ cId) | |
929 { | |
930 psaCC_FreeCtbNtry (cId); | |
931 } | |
932 #ifdef SIM_TOOLKIT | |
933 } | |
934 #endif /* SIM_TOOLKIT */ | |
935 } | |
936 /*end patch BE */ | |
937 | |
938 switch(CHLDaddInfo) | |
939 { | |
940 case (CHLD_ADD_INFO_DIAL_CAL): | |
941 cId = psaCC_ctbFindCall( OWN_SRC_INV, NO_VLD_CS, CT_MOC ); | |
942 if (cId NEQ NO_ENTRY) | |
943 { | |
944 cmhCC_NewCall(cId,(T_ACI_CMD_SRC)psaCC_ctb(cId)->curSrc,AT_CMD_D); | |
945 } | |
946 break; | |
947 default: | |
948 break; | |
949 } | |
950 cmhCC_ChngWaitingToIncoming(); | |
951 /* free the primitive buffer */ | |
952 PFREE (mncc_release_cnf); | |
953 | |
954 } | |
955 | |
956 /* | |
957 +-------------------------------------------------------------------+ | |
958 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
959 | ROUTINE : psa_mncc_disconnect_ind | | |
960 +-------------------------------------------------------------------+ | |
961 | |
962 PURPOSE : processes the MNCC_DISCONNECT_IND primitive send by CC. | |
963 this indicates the disconnection of a call. | |
964 | |
965 */ | |
966 | |
967 GLOBAL void psa_mncc_disconnect_ind | |
968 ( T_MNCC_DISCONNECT_IND *mncc_disconnect_ind ) | |
969 { | |
970 SHORT cId; /* holds call id */ | |
971 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ | |
972 BOOL held_call = FALSE; | |
973 | |
974 TRACE_FUNCTION ("psa_mncc_disconnect_ind()"); | |
975 | |
976 /* | |
977 *------------------------------------------------------------------- | |
978 * find call in call table | |
979 *------------------------------------------------------------------- | |
980 */ | |
981 cId = psaCC_ctbFindTi( mncc_disconnect_ind -> ti ); | |
982 | |
983 if( cId < 0 ) | |
984 { | |
985 /* | |
986 * ignore primitive, due to not found transaction identifier. | |
987 */ | |
988 TRACE_EVENT ("primitive rejected due to unused ti"); | |
989 PFREE(mncc_disconnect_ind); | |
990 return; | |
991 } | |
992 psaCC_StopDTMF ( cId ); /* HM 27.07.00 */ | |
993 | |
994 /* | |
995 *------------------------------------------------------------------- | |
996 * update shared parameter and notify ACI | |
997 *------------------------------------------------------------------- | |
998 */ | |
999 pCtbNtry = ccShrdPrm.ctb[cId]; | |
1000 | |
1001 pCtbNtry -> curCs = mncc_disconnect_ind -> cause; | |
1002 | |
1003 if( mncc_disconnect_ind->diagnostic EQ MNCC_DIAG_CCBS_POSSIBLE ) | |
1004 { | |
1005 pCtbNtry -> CCBSstat = CCBSS_PSSBL; | |
1006 } | |
1007 | |
1008 /* CQ 23619: copy ss diagnostic to shared parameters >> */ | |
1009 pCtbNtry->ssDiag = mncc_disconnect_ind->ss_diag; | |
1010 /* CQ 23619 << */ | |
1011 | |
1012 #if 0 | |
1013 if( mncc_disconnect_ind -> cause NEQ CAUSE_NOT_PRES ) | |
1014 { | |
1015 pCtbNtry -> nrmCs = mncc_disconnect_ind -> cause; | |
1016 ccShrdPrm.cIdFail = cId; | |
1017 #ifdef FF_EM_MODE | |
1018 em_relcs = mncc_disconnect_ind -> cause; | |
1019 #endif /* FF_EM_MODE */ | |
1020 } | |
1021 #endif | |
1022 | |
1023 pCtbNtry -> nrmCs = mncc_disconnect_ind -> cause; /* Recheck ### */ | |
1024 ccShrdPrm.cIdFail = cId; /* Recheck ### */ | |
1025 #ifdef FF_EM_MODE | |
1026 em_relcs = mncc_disconnect_ind -> cause; /* Recheck ### */ | |
1027 #endif /* FF_EM_MODE */ | |
1028 | |
1029 /* remember if call is currently on hold */ | |
1030 if (pCtbNtry -> calStat EQ CS_HLD) | |
1031 held_call = TRUE; | |
1032 | |
1033 /* calStat has to be set before calling psaCC_chkPrgDesc, otherwise | |
1034 no CPI event will be send */ | |
1035 pCtbNtry -> calStat = CS_DSC_REQ; | |
1036 | |
1037 /* check for TTY service */ | |
1038 /* cmhCC_TTY_Control ( cId ); */ | |
1039 | |
1040 /* check for progress descriptions */ | |
1041 psaCC_chkPrgDesc ( cId, mncc_disconnect_ind -> progress_desc, MT_DISC ); | |
1042 | |
1043 pCtbNtry -> rslt = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); | |
1044 pCtbNtry -> rejCs = CAUSE_MAKE(DEFBY_CONDAT, ORIGSIDE_MS, MNCC_CC_ORIGINATING_ENTITY, NOT_PRESENT_8BIT); | |
1045 | |
1046 pCtbNtry -> numRawCauseBytes = mncc_disconnect_ind -> c_raw_cause; | |
1047 pCtbNtry -> rawCauseBytes = mncc_disconnect_ind -> raw_cause; | |
1048 | |
1049 psaCC_send_satevent( EVENT_CALL_DISC, cId , FAR_END, TRUE ); | |
1050 | |
1051 pCtbNtry -> numRawCauseBytes = 0; /* Reset the cause value after sending the info to SAT */ | |
1052 | |
1053 /* If call was held upon mncc_disconnect_ind it is cleared anyway */ | |
1054 if (held_call EQ TRUE) | |
1055 { | |
1056 TRACE_EVENT ("Release a held call"); | |
1057 cmhCC_CallDisconnected (cId); | |
1058 psaCC_ClearCall (cId); | |
1059 } | |
1060 else | |
1061 { | |
1062 switch( cmhCC_getcalltype(cId) ) | |
1063 { | |
1064 case( VOICE_CALL ): | |
1065 { | |
1066 /* | |
1067 * if in-band tones are available and TCH is assigned, request to disconnect the call | |
1068 * GSM 04.08/5.4.4.1.1.1 | |
1069 */ | |
1070 /* | |
1071 TRACE_EVENT("psa_mncc_disconnect_ind(): --> VOICE CALL"); | |
1072 if ((pCtbNtry -> inBndTns EQ TRUE) | |
1073 AND (pCtbNtry -> CCBSstat EQ NO_VLD_CCBSS) | |
1074 AND (ccShrdPrm.TCHasg EQ TRUE)) | |
1075 { | |
1076 cmhCC_DisconnectCall (cId); | |
1077 } | |
1078 else | |
1079 { | |
1080 cmhCC_CallDisconnected (cId); | |
1081 } | |
1082 */ | |
1083 /* check conditions for redialling */ | |
1084 if((pCtbNtry->curCmd NEQ AT_CMD_H) AND | |
1085 (pCtbNtry->curCmd NEQ AT_CMD_CHUP)) | |
1086 { | |
1087 cmhCC_redialCheck(cId); | |
1088 } | |
1089 | |
1090 | |
1091 /* | |
1092 * for CCBS support the "Prolonged Clearing Procedure" | |
1093 * GSM 04.08/5.4.4.2.1 | |
1094 */ | |
1095 cmhCC_CallDisconnected (cId); | |
1096 | |
1097 if ((pCtbNtry->inBndTns EQ TRUE) /* 5.4.4.2.1.1 */ | |
1098 AND (pCtbNtry->CCBSstat EQ NO_VLD_CCBSS)) | |
1099 { | |
1100 if (ccShrdPrm.TCHasg NEQ TRUE) | |
1101 { | |
1102 TRACE_EVENT ("4.08/5.4.4.2.1.1 i)"); | |
1103 psaCC_ClearCall (cId); | |
1104 } | |
1105 else | |
1106 { | |
1107 TRACE_EVENT ("4.08/5.4.4.2.1.1 ii)"); | |
1108 psaCC_setSpeechMode(); | |
1109 } | |
1110 } | |
1111 else if (pCtbNtry->CCBSstat EQ CCBSS_PSSBL) /* 5.4.4.2.2.1 */ | |
1112 { | |
1113 TRACE_EVENT ("4.08/5.4.4.2.2.1"); | |
1114 psaCC_setSpeechMode(); | |
1115 cmhCC_SndDiscRsn( cId ); /* FIXME: to emmit BUSY, but this is not good here | |
1116 since BUSY is final result code and will be | |
1117 emitted on Release again !!!!! */ | |
1118 } | |
1119 else if ((pCtbNtry->inBndTns NEQ TRUE) /* 5.4.4.2.3.1 */ | |
1120 AND (pCtbNtry->CCBSstat EQ NO_VLD_CCBSS)) | |
1121 { | |
1122 TRACE_EVENT ("4.08/5.4.4.2.3.1"); | |
1123 psaCC_ClearCall (cId); | |
1124 } | |
1125 else /* 5.4.4.2.3.2 */ | |
1126 { | |
1127 TRACE_EVENT ("4.08/5.4.4.2.3.2"); | |
1128 psaCC_ClearCall (cId); | |
1129 } | |
1130 break; | |
1131 } | |
1132 default: /* all non voice calls */ | |
1133 { | |
1134 /* | |
1135 * see cmh_cc.h T_CC_CALL_TYPE for all other call types | |
1136 */ | |
1137 TRACE_EVENT("psa_mncc_disconnect_ind(): --> DATA CALL"); | |
1138 cmhCC_CallDisconnected (cId); | |
1139 psaCC_ClearCall (cId); | |
1140 break; | |
1141 } | |
1142 } | |
1143 } /* else */ | |
1144 | |
1145 /* free the primitive buffer */ | |
1146 PFREE (mncc_disconnect_ind); | |
1147 } | |
1148 | |
1149 /* | |
1150 +-------------------------------------------------------------------+ | |
1151 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
1152 | ROUTINE : psa_mncc_alert_ind | | |
1153 +-------------------------------------------------------------------+ | |
1154 | |
1155 PURPOSE : processes the MNCC_ALERT_IND primitive send by CC. | |
1156 this indicates that the called party is alerted. | |
1157 | |
1158 */ | |
1159 | |
1160 GLOBAL void psa_mncc_alert_ind | |
1161 ( T_MNCC_ALERT_IND *mncc_alert_ind ) | |
1162 { | |
1163 SHORT cId; /* holds call id */ | |
1164 | |
1165 TRACE_FUNCTION ("psa_mncc_alert_ind()"); | |
1166 | |
1167 /* | |
1168 *------------------------------------------------------------------- | |
1169 * find call in call table | |
1170 *------------------------------------------------------------------- | |
1171 */ | |
1172 cId = psaCC_ctbFindTi( mncc_alert_ind -> ti ); | |
1173 | |
1174 if( cId < 0 ) | |
1175 { | |
1176 /* | |
1177 * ignore primitive, due to not found transaction identifier. | |
1178 */ | |
1179 TRACE_EVENT ("primitive rejected due to unused ti"); | |
1180 PFREE(mncc_alert_ind); | |
1181 return; | |
1182 } | |
1183 | |
1184 /* | |
1185 *------------------------------------------------------------------- | |
1186 * update shared parameter and notify ACI | |
1187 *------------------------------------------------------------------- | |
1188 */ | |
1189 psaCC_ctb(cId)->alrtStat = AS_SND; | |
1190 psaCC_ctb(cId)->curCs = MNCC_CAUSE_NO_MS_CAUSE; | |
1191 | |
1192 /* check for progress descriptions */ | |
1193 psaCC_chkPrgDesc ( cId, mncc_alert_ind -> progress_desc, MT_ALRT ); | |
1194 | |
1195 /* check for TTY service */ | |
1196 cmhCC_TTY_Control ( cId, TTY_START ); | |
1197 /* | |
1198 *------------------------------------------------------------------- | |
1199 * free the primitive buffer | |
1200 *------------------------------------------------------------------- | |
1201 */ | |
1202 PFREE (mncc_alert_ind); | |
1203 } | |
1204 | |
1205 /* | |
1206 +-------------------------------------------------------------------+ | |
1207 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
1208 | ROUTINE : psa_mncc_call_proceed_ind| | |
1209 +-------------------------------------------------------------------+ | |
1210 | |
1211 PURPOSE : processes the MNCC_CALL_PROCEED_IND primitive send by CC. | |
1212 this indicates a call proceeding information for a call. | |
1213 | |
1214 */ | |
1215 | |
1216 GLOBAL void psa_mncc_call_proceed_ind | |
1217 ( T_MNCC_CALL_PROCEED_IND *mncc_call_proceed_ind ) | |
1218 { | |
1219 SHORT cId; /* holds call id */ | |
1220 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ | |
1221 | |
1222 TRACE_FUNCTION ("psa_mncc_call_proceed_ind()"); | |
1223 | |
1224 /* | |
1225 *------------------------------------------------------------------- | |
1226 * find call in call table | |
1227 *------------------------------------------------------------------- | |
1228 */ | |
1229 cId = psaCC_ctbFindTi( mncc_call_proceed_ind -> ti ); | |
1230 | |
1231 if( cId < 0 ) | |
1232 { | |
1233 /* | |
1234 * ignore primitive, due to not found transaction identifier. | |
1235 */ | |
1236 TRACE_EVENT ("primitive rejected due to unused ti"); | |
1237 PFREE(mncc_call_proceed_ind); | |
1238 return; | |
1239 } | |
1240 | |
1241 /* | |
1242 *------------------------------------------------------------------- | |
1243 * update shared parameter and notify ACI | |
1244 *------------------------------------------------------------------- | |
1245 */ | |
1246 pCtbNtry = ccShrdPrm.ctb[cId]; | |
1247 pCtbNtry -> curCs = MNCC_CAUSE_NO_MS_CAUSE; | |
1248 | |
1249 memcpy( &(pCtbNtry->BC[0]),&(mncc_call_proceed_ind->bcpara), | |
1250 sizeof( T_MNCC_bcpara) ); | |
1251 memcpy( &(pCtbNtry->BC[1]),&(mncc_call_proceed_ind->bcpara2), | |
1252 sizeof( T_MNCC_bcpara) ); | |
1253 pCtbNtry -> rptInd = mncc_call_proceed_ind -> ri; | |
1254 | |
1255 /* check for progress descriptions */ | |
1256 psaCC_chkPrgDesc ( cId, mncc_call_proceed_ind -> progress_desc, MT_PROC ); | |
1257 | |
1258 /* check for TTY service */ | |
1259 cmhCC_TTY_Control ( cId, TTY_START ); | |
1260 /* | |
1261 *------------------------------------------------------------------- | |
1262 * free the primitive buffer | |
1263 *------------------------------------------------------------------- | |
1264 */ | |
1265 PFREE (mncc_call_proceed_ind); | |
1266 | |
1267 } | |
1268 | |
1269 /* | |
1270 +-------------------------------------------------------------------+ | |
1271 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
1272 | ROUTINE : psa_mncc_progress_ind | | |
1273 +-------------------------------------------------------------------+ | |
1274 | |
1275 PURPOSE : processes the MNCC_PROGRESS_IND primitive send by CC. | |
1276 this indicates a progress description for a call. | |
1277 | |
1278 */ | |
1279 | |
1280 GLOBAL void psa_mncc_progress_ind | |
1281 ( T_MNCC_PROGRESS_IND *mncc_progress_ind ) | |
1282 { | |
1283 SHORT cId; /* holds call id */ | |
1284 | |
1285 TRACE_FUNCTION ("psa_mncc_progress_ind()"); | |
1286 | |
1287 /* | |
1288 *------------------------------------------------------------------- | |
1289 * find call in call table | |
1290 *------------------------------------------------------------------- | |
1291 */ | |
1292 cId = psaCC_ctbFindTi( mncc_progress_ind -> ti ); | |
1293 | |
1294 | |
1295 if( cId < 0 ) | |
1296 { | |
1297 /* | |
1298 * ignore primitive, due to not found transaction identifier. | |
1299 */ | |
1300 TRACE_EVENT ("primitive rejected due to unused ti"); | |
1301 PFREE(mncc_progress_ind); | |
1302 return; | |
1303 } | |
1304 psaCC_ctb(cId)->curCs = MNCC_CAUSE_NO_MS_CAUSE; | |
1305 | |
1306 /* | |
1307 * check for progress descriptions | |
1308 */ | |
1309 psaCC_chkPrgDesc ( cId, mncc_progress_ind -> progress_desc, MT_PROGR ); | |
1310 | |
1311 /* | |
1312 *------------------------------------------------------------------- | |
1313 * free the primitive buffer | |
1314 *------------------------------------------------------------------- | |
1315 */ | |
1316 PFREE (mncc_progress_ind); | |
1317 | |
1318 } | |
1319 | |
1320 /* | |
1321 +-------------------------------------------------------------------+ | |
1322 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
1323 | ROUTINE : psa_mncc_hold_cnf | | |
1324 +-------------------------------------------------------------------+ | |
1325 | |
1326 PURPOSE : processes the MNCC_HOLD_CNF primitive send by CC. | |
1327 this confirmates that a call is being held. | |
1328 | |
1329 */ | |
1330 | |
1331 GLOBAL void psa_mncc_hold_cnf | |
1332 ( T_MNCC_HOLD_CNF *mncc_hold_cnf ) | |
1333 { | |
1334 SHORT cId; /* holds call id */ | |
1335 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ | |
1336 | |
1337 TRACE_FUNCTION ("psa_mncc_hold_cnf()"); | |
1338 | |
1339 /* | |
1340 *------------------------------------------------------------------- | |
1341 * find call in call table | |
1342 *------------------------------------------------------------------- | |
1343 */ | |
1344 cId = psaCC_ctbFindTi( mncc_hold_cnf -> ti ); | |
1345 | |
1346 if( cId < 0 ) | |
1347 { | |
1348 /* | |
1349 * ignore primitive, due to not found transaction identifier. | |
1350 */ | |
1351 TRACE_EVENT ("primitive rejected due to unused ti"); | |
1352 PFREE(mncc_hold_cnf); | |
1353 return; | |
1354 } | |
1355 | |
1356 /* | |
1357 *------------------------------------------------------------------- | |
1358 * update shared parameter and notify ACI | |
1359 *------------------------------------------------------------------- | |
1360 */ | |
1361 pCtbNtry = ccShrdPrm.ctb[cId]; | |
1362 | |
1363 switch( mncc_hold_cnf -> cause ) | |
1364 { | |
1365 case( MNCC_CAUSE_HOLD_SUCCESS ): /* successful, call held */ | |
1366 case( MNCC_CAUSE_SUCCESS ): | |
1367 case( MNCC_CAUSE_NO_MS_CAUSE ): | |
1368 | |
1369 pCtbNtry -> calStat = CS_HLD; | |
1370 | |
1371 psaCC_setSpeechMode (); | |
1372 | |
1373 /* check for TTY service */ | |
1374 cmhCC_TTY_Control ( cId, TTY_PAUSE ); | |
1375 break; | |
1376 | |
1377 default: /* unsuccessful, call state unchanged */ | |
1378 | |
1379 ccShrdPrm.cIdFail = cId; | |
1380 pCtbNtry -> calStat = CS_ACT; | |
1381 break; | |
1382 } | |
1383 | |
1384 pCtbNtry -> rslt = mncc_hold_cnf -> cause; | |
1385 | |
1386 cmhCC_CallHeld(cId); | |
1387 | |
1388 /* | |
1389 *------------------------------------------------------------------- | |
1390 * free the primitive buffer | |
1391 *------------------------------------------------------------------- | |
1392 */ | |
1393 PFREE (mncc_hold_cnf); | |
1394 | |
1395 } | |
1396 | |
1397 /* | |
1398 +-------------------------------------------------------------------+ | |
1399 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
1400 | ROUTINE : psa_mncc_retrieve_cnf | | |
1401 +-------------------------------------------------------------------+ | |
1402 | |
1403 PURPOSE : processes the MNCC_RETRIEVE_CNF primitive send by CC. | |
1404 this confirmates that a call is retrieved. | |
1405 | |
1406 */ | |
1407 | |
1408 GLOBAL void psa_mncc_retrieve_cnf | |
1409 ( T_MNCC_RETRIEVE_CNF *mncc_retrieve_cnf ) | |
1410 { | |
1411 SHORT cId; /* holds call id */ | |
1412 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ | |
1413 | |
1414 TRACE_FUNCTION ("psa_mncc_retrieve_cnf()"); | |
1415 | |
1416 /* | |
1417 *------------------------------------------------------------------- | |
1418 * find call in call table | |
1419 *------------------------------------------------------------------- | |
1420 */ | |
1421 cId = psaCC_ctbFindTi( mncc_retrieve_cnf -> ti ); | |
1422 | |
1423 if( cId < 0 ) | |
1424 { | |
1425 /* | |
1426 * ignore primitive, due to not found transaction identifier. | |
1427 */ | |
1428 TRACE_EVENT ("primitive rejected due to unused ti"); | |
1429 PFREE(mncc_retrieve_cnf); | |
1430 return; | |
1431 } | |
1432 | |
1433 /* | |
1434 *------------------------------------------------------------------- | |
1435 * update shared parameter and notify ACI | |
1436 *------------------------------------------------------------------- | |
1437 */ | |
1438 pCtbNtry = ccShrdPrm.ctb[cId]; | |
1439 | |
1440 switch( mncc_retrieve_cnf -> cause ) | |
1441 { | |
1442 case( MNCC_CAUSE_RETRIEVE_SUCCESS ): /* successful, call active */ | |
1443 | |
1444 pCtbNtry -> calStat = CS_ACT; | |
1445 | |
1446 /* switch on vocoder */ | |
1447 psaCC_setSpeechMode (); | |
1448 | |
1449 /* check for TTY service */ | |
1450 cmhCC_TTY_Control ( cId, TTY_START ); | |
1451 break; | |
1452 | |
1453 default: /* unsuccessful, call state unchanged */ | |
1454 | |
1455 ccShrdPrm.cIdFail = cId; | |
1456 pCtbNtry -> calStat = CS_HLD; | |
1457 break; | |
1458 } | |
1459 | |
1460 pCtbNtry -> rslt = mncc_retrieve_cnf -> cause; | |
1461 | |
1462 cmhCC_CallRetrieved (cId); | |
1463 | |
1464 /* | |
1465 *------------------------------------------------------------------- | |
1466 * free the primitive buffer | |
1467 *------------------------------------------------------------------- | |
1468 */ | |
1469 PFREE (mncc_retrieve_cnf); | |
1470 | |
1471 } | |
1472 | |
1473 /* | |
1474 +-------------------------------------------------------------------+ | |
1475 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
1476 | ROUTINE : psa_mncc_sync_ind | | |
1477 +-------------------------------------------------------------------+ | |
1478 | |
1479 PURPOSE : processes the MNCC_SYNC_IND primitive send by CC. | |
1480 this indicates the change of the channel mode. | |
1481 | |
1482 */ | |
1483 | |
1484 GLOBAL void psa_mncc_sync_ind( T_MNCC_SYNC_IND *mncc_sync_ind ) | |
1485 { | |
1486 SHORT cId = 0; /* holds call id */ | |
1487 | |
1488 TRACE_FUNCTION ("psa_mncc_sync_ind()"); | |
1489 | |
1490 /* | |
1491 cause cause 4.6 UBYTE | |
1492 channel mode chm 4.14 STRUCT | |
1493 | |
1494 ch_type 0 CH_SDCCH SDCCH channel | |
1495 1 CH_TCH_F TCH Fullrate | |
1496 2 CH_TCH_H TCH Halfrate | |
1497 | |
1498 ch_mode 0 CHM_SIG_ONLY signalling only | |
1499 1 CHM_SPEECH speech full rate or half rate version 1 | |
1500 33 CHM_SPEECH_V2 speech full rate or half rate version 2 | |
1501 65 CHM_SPEECH_V3 speech full rate or half rate version 3 | |
1502 3 CHM_DATA_9_6 data 9.6 kBit/s | |
1503 11 CHM_DATA_4_8 data 4.8 kBit/s | |
1504 19 CHM_DATA_2_4 data 2.4 kBit/s | |
1505 15 CHM_DATA_14_4 data 14.4 kBit/s | |
1506 */ | |
1507 | |
1508 TRACE_EVENT_P4("MNCC_SYNC_IND ti: %d, cause: %d, ch_type: %d, ch_mode: %d", | |
1509 mncc_sync_ind -> ti, | |
1510 mncc_sync_ind -> cause, | |
1511 mncc_sync_ind -> ch_info.ch_type, | |
1512 mncc_sync_ind -> ch_info.ch_mode); | |
1513 | |
1514 /* update shared parameter */ | |
1515 ccShrdPrm.syncCs = mncc_sync_ind -> cause; | |
1516 #ifdef FF_EM_MODE | |
1517 em_relcs = mncc_sync_ind -> cause; | |
1518 #endif /* FF_EM_MODE */ | |
1519 | |
1520 /* Inform Advice of Charge Module */ | |
1521 switch (mncc_sync_ind->cause) | |
1522 { | |
1523 case MNCC_CAUSE_REEST_STARTED: | |
1524 for( cId = 0; cId < MAX_CALL_NR; cId++ ) | |
1525 aoc_info (cId, AOC_SUSPEND_AOC); | |
1526 break; | |
1527 case MNCC_CAUSE_REEST_FINISHED: | |
1528 ccShrdPrm.aocRsmpPend = 1; | |
1529 break; | |
1530 } | |
1531 | |
1532 /* switch channel mode */ | |
1533 if( mncc_sync_ind -> ch_info.ch_mode NEQ NOT_PRESENT_8BIT ) | |
1534 { | |
1535 ccShrdPrm.chMod = mncc_sync_ind -> ch_info.ch_mode; | |
1536 ccShrdPrm.chType = mncc_sync_ind -> ch_info.ch_type; | |
1537 ccShrdPrm.TCHasg = TRUE; | |
1538 } | |
1539 | |
1540 if ( ccShrdPrm.aocRsmpPend AND | |
1541 (ccShrdPrm.chMod EQ MNCC_CHM_SPEECH) OR | |
1542 (ccShrdPrm.chMod EQ MNCC_CHM_SPEECH_V2) OR | |
1543 (ccShrdPrm.chMod EQ MNCC_CHM_SPEECH_V3) ) | |
1544 { | |
1545 ccShrdPrm.aocRsmpPend = 0; | |
1546 for( cId = 0; cId < MAX_CALL_NR; cId++ ) | |
1547 aoc_info (cId, AOC_RESUME_AOC); | |
1548 } | |
1549 | |
1550 if( mncc_sync_ind -> ch_info.ch_mode NEQ NOT_PRESENT_8BIT ) | |
1551 { | |
1552 /* service a pending alert */ | |
1553 for( cId = 0; cId < MAX_CALL_NR; cId++ ) | |
1554 { | |
1555 if (ccShrdPrm.ctb[cId] NEQ NULL) | |
1556 { | |
1557 psaCC_ctb(cId)->curCs = mncc_sync_ind -> cause; | |
1558 | |
1559 if( psaCC_ctb(cId)->alrtStat EQ AS_PND AND | |
1560 psaCC_ctb(cId)->calStat EQ CS_ACT_REQ ) | |
1561 { | |
1562 { | |
1563 /* indicate alerting to network */ | |
1564 PALLOC (mncc_alert_req, MNCC_ALERT_REQ); | |
1565 mncc_alert_req -> ti = psaCC_ctb(cId)->ti; | |
1566 PSENDX (CC, mncc_alert_req); | |
1567 psaCC_ctb(cId)->alrtStat = AS_SND; | |
1568 } | |
1569 cmhCC_IncomingCall (cId); /* indicate an incoming call */ | |
1570 } | |
1571 if (psaCC_ctb(cId)->calStat NEQ CS_HLD AND | |
1572 psaCC_ctb(cId)->calStat NEQ CS_IDL) | |
1573 { | |
1574 /* check for TTY service */ | |
1575 cmhCC_TTY_Control ( cId, TTY_TCH ); | |
1576 } | |
1577 } | |
1578 } | |
1579 } | |
1580 psaCC_setSpeechMode (); | |
1581 | |
1582 /* Remember cause for Call Reestablishment*/ | |
1583 | |
1584 if (mncc_sync_ind -> cause EQ MNCC_CAUSE_REEST_FINISHED | |
1585 OR mncc_sync_ind -> cause EQ MNCC_CAUSE_REEST_STARTED) | |
1586 { | |
1587 for( cId = 0; cId < MAX_CALL_NR; cId++ ) | |
1588 { | |
1589 if (ccShrdPrm.ctb[cId] NEQ NULL) | |
1590 { | |
1591 psaCC_ctb(cId)->curCs = mncc_sync_ind -> cause; | |
1592 } | |
1593 } | |
1594 } | |
1595 | |
1596 cId = psaCC_ctbFindTi( mncc_sync_ind -> ti ); | |
1597 | |
1598 /* For channel synchronization events the cId needs not to be valid here */ | |
1599 cmhCC_Synchronized( cId ); | |
1600 | |
1601 | |
1602 /* free the primitive buffer */ | |
1603 PFREE (mncc_sync_ind); | |
1604 } | |
1605 | |
1606 /* | |
1607 +-------------------------------------------------------------------+ | |
1608 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
1609 | ROUTINE : psa_mncc_user_ind | | |
1610 +-------------------------------------------------------------------+ | |
1611 | |
1612 PURPOSE : processes the MNCC_USER_IND primitive send by CC. | |
1613 this indicates the receiving of user data. | |
1614 */ | |
1615 | |
1616 GLOBAL void psa_mncc_user_ind( T_MNCC_USER_IND *mncc_user_ind ) | |
1617 { | |
1618 TRACE_FUNCTION ("psa_mncc_user_ind()"); | |
1619 | |
1620 PFREE (mncc_user_ind); | |
1621 } | |
1622 | |
1623 /* | |
1624 +-------------------------------------------------------------------+ | |
1625 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
1626 | ROUTINE : psa_mncc_start_dtmf_cnf | | |
1627 +-------------------------------------------------------------------+ | |
1628 | |
1629 PURPOSE : processes the MNCC_START_DTMF_CNF primitive send by CC. | |
1630 this is a confirmation for the sent DTMF tones. | |
1631 | |
1632 */ | |
1633 | |
1634 GLOBAL void psa_mncc_start_dtmf_cnf | |
1635 ( T_MNCC_START_DTMF_CNF *mncc_start_dtmf_cnf ) | |
1636 { | |
1637 SHORT cId; /* holds call id */ | |
1638 | |
1639 TRACE_FUNCTION ("psa_mncc_start_dtmf_cnf()"); | |
1640 | |
1641 /* | |
1642 *------------------------------------------------------------------- | |
1643 * find call in call table | |
1644 *------------------------------------------------------------------- | |
1645 */ | |
1646 cId = psaCC_ctbFindTi( mncc_start_dtmf_cnf -> ti ); | |
1647 | |
1648 if( cId < 0 ) | |
1649 { | |
1650 /* | |
1651 * ignore primitive, due to not found transaction identifier. | |
1652 */ | |
1653 TRACE_EVENT ("primitive rejected due to unused ti"); | |
1654 PFREE(mncc_start_dtmf_cnf); | |
1655 return; | |
1656 } | |
1657 | |
1658 /* | |
1659 *------------------------------------------------------------------- | |
1660 * update shared parameter and notify ACI | |
1661 *------------------------------------------------------------------- | |
1662 */ | |
1663 psaCC_ctb(cId)->nrmCs = mncc_start_dtmf_cnf -> cause; | |
1664 if ((mncc_start_dtmf_cnf->cause EQ MNCC_CAUSE_DTMF_STOP_SUCCESS) AND | |
1665 (mncc_start_dtmf_cnf->dtmf_mod EQ MNCC_DTMF_MOD_MAN_STOP)) | |
1666 { | |
1667 /* Reset the current dtmf digit */ | |
1668 ccShrdPrm.dtmf.cur = 0; | |
1669 } | |
1670 #ifdef FF_EM_MODE | |
1671 em_relcs = mncc_start_dtmf_cnf -> cause; | |
1672 #endif /* FF_EM_MODE */ | |
1673 | |
1674 psaCC_DTMFSent( cId ); | |
1675 | |
1676 /* | |
1677 *------------------------------------------------------------------- | |
1678 * free the primitive buffer | |
1679 *------------------------------------------------------------------- | |
1680 */ | |
1681 PFREE (mncc_start_dtmf_cnf); | |
1682 | |
1683 } | |
1684 | |
1685 /* | |
1686 +-------------------------------------------------------------------+ | |
1687 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
1688 | ROUTINE : psa_mncc_modify_ind | | |
1689 +-------------------------------------------------------------------+ | |
1690 | |
1691 PURPOSE : processes the MNCC_MODIFY_IND primitive send by CC. | |
1692 this indicates a mobile terminated in-call modification. | |
1693 | |
1694 */ | |
1695 | |
1696 GLOBAL void psa_mncc_modify_ind | |
1697 ( T_MNCC_MODIFY_IND *mncc_modify_ind ) | |
1698 { | |
1699 SHORT cId; /* holds call id */ | |
1700 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ | |
1701 | |
1702 TRACE_FUNCTION ("psa_mncc_modify_ind()"); | |
1703 | |
1704 /* | |
1705 *------------------------------------------------------------------- | |
1706 * find call in call table | |
1707 *------------------------------------------------------------------- | |
1708 */ | |
1709 cId = psaCC_ctbFindTi( mncc_modify_ind -> ti ); | |
1710 | |
1711 if( cId < 0 ) | |
1712 { | |
1713 /* | |
1714 * ignore primitive, due to not found transaction identifier. | |
1715 */ | |
1716 TRACE_EVENT ("primitive rejected due to unused ti"); | |
1717 PFREE(mncc_modify_ind); | |
1718 return; | |
1719 } | |
1720 | |
1721 /* check for TTY service */ | |
1722 cmhCC_TTY_Control ( cId, TTY_PAUSE ); | |
1723 | |
1724 /* | |
1725 *------------------------------------------------------------------- | |
1726 * update shared parameter and notify ACI | |
1727 *------------------------------------------------------------------- | |
1728 */ | |
1729 pCtbNtry = ccShrdPrm.ctb[cId]; | |
1730 | |
1731 pCtbNtry -> curBC = (pCtbNtry -> curBC EQ 0)?1:0; | |
1732 pCtbNtry -> rslt = MNCC_CAUSE_MODIFY_SUCCESS; /* SBK-02-07-30: possibly to be revised as strictly speaking ACI is orignating entity */ | |
1733 | |
1734 cmhCC_CallModified (cId); | |
1735 | |
1736 /* check for TTY service */ | |
1737 cmhCC_TTY_Control ( cId, TTY_START ); | |
1738 | |
1739 psaCC_StopDTMF ( cId ); | |
1740 /* | |
1741 *------------------------------------------------------------------- | |
1742 * free the primitive buffer | |
1743 *------------------------------------------------------------------- | |
1744 */ | |
1745 PFREE (mncc_modify_ind); | |
1746 | |
1747 } | |
1748 | |
1749 /* | |
1750 +-------------------------------------------------------------------+ | |
1751 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
1752 | ROUTINE : psa_mncc_modify_cnf | | |
1753 +-------------------------------------------------------------------+ | |
1754 | |
1755 PURPOSE : processes the MNCC_MODIFY_CNF primitive send by CC. | |
1756 this indicates the result for a mobile originated in-call | |
1757 modification. | |
1758 | |
1759 */ | |
1760 | |
1761 GLOBAL void psa_mncc_modify_cnf | |
1762 ( T_MNCC_MODIFY_CNF *mncc_modify_cnf ) | |
1763 { | |
1764 SHORT cId; /* holds call id */ | |
1765 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ | |
1766 | |
1767 TRACE_FUNCTION ("psa_mncc_modify_cnf()"); | |
1768 | |
1769 /* | |
1770 *------------------------------------------------------------------- | |
1771 * find call in call table | |
1772 *------------------------------------------------------------------- | |
1773 */ | |
1774 cId = psaCC_ctbFindTi( mncc_modify_cnf -> ti ); | |
1775 | |
1776 if( cId < 0 ) | |
1777 { | |
1778 /* | |
1779 * ignore primitive, due to not found transaction identifier. | |
1780 */ | |
1781 TRACE_EVENT ("primitive rejected due to unused ti"); | |
1782 PFREE(mncc_modify_cnf); | |
1783 return; | |
1784 } | |
1785 | |
1786 /* | |
1787 *------------------------------------------------------------------- | |
1788 * update shared parameter and notify ACI | |
1789 *------------------------------------------------------------------- | |
1790 */ | |
1791 pCtbNtry = ccShrdPrm.ctb[cId]; | |
1792 | |
1793 pCtbNtry -> rslt = mncc_modify_cnf -> cause; | |
1794 | |
1795 switch( mncc_modify_cnf -> cause ) | |
1796 { | |
1797 case( MNCC_CAUSE_MODIFY_SUCCESS ): /* successful modification */ | |
1798 | |
1799 pCtbNtry -> curBC = (pCtbNtry -> curBC EQ 0)?1:0; | |
1800 break; | |
1801 | |
1802 default: /* unsuccessful modification */ | |
1803 | |
1804 ccShrdPrm.cIdFail = cId; | |
1805 break; | |
1806 } | |
1807 psaCC_ctb(cId)->calStat = CS_ACT; | |
1808 | |
1809 cmhCC_CallModified (cId); | |
1810 | |
1811 /* check for TTY service */ | |
1812 cmhCC_TTY_Control ( cId, TTY_START ); | |
1813 | |
1814 /* | |
1815 *------------------------------------------------------------------- | |
1816 * free the primitive buffer | |
1817 *------------------------------------------------------------------- | |
1818 */ | |
1819 PFREE (mncc_modify_cnf); | |
1820 | |
1821 } | |
1822 | |
1823 /* | |
1824 +-------------------------------------------------------------------+ | |
1825 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
1826 | ROUTINE : psa_mncc_bearer_cap_cnf | | |
1827 +-------------------------------------------------------------------+ | |
1828 | |
1829 PURPOSE : processes the MNCC_BEARER_CAP_CNF primitive send by CC. | |
1830 this is the result of the requested bearer coding/decoding. | |
1831 | |
1832 */ | |
1833 | |
1834 GLOBAL void psa_mncc_bearer_cap_cnf | |
1835 ( T_MNCC_BEARER_CAP_CNF *mncc_bearer_cap_cnf ) | |
1836 { | |
1837 | |
1838 TRACE_FUNCTION ("psa_mncc_bearer_cap_cnf()"); | |
1839 | |
1840 /* | |
1841 *------------------------------------------------------------------- | |
1842 * determine request id | |
1843 *------------------------------------------------------------------- | |
1844 */ | |
1845 switch( mncc_bearer_cap_cnf -> req_id ) | |
1846 { | |
1847 | |
1848 #ifdef SIM_TOOLKIT | |
1849 | |
1850 case( BCRI_SAT ): | |
1851 | |
1852 switch( mncc_bearer_cap_cnf -> bc_mod ) | |
1853 { | |
1854 case( MNCC_BC_MOD_CODE ): | |
1855 | |
1856 cmhSAT_ResCapCode ( mncc_bearer_cap_cnf -> cause, | |
1857 &mncc_bearer_cap_cnf -> bcconf, | |
1858 &mncc_bearer_cap_cnf -> bcconf2); | |
1859 | |
1860 break; | |
1861 | |
1862 case( MNCC_BC_MOD_DECODE ): | |
1863 | |
1864 cmhSAT_ResCapDecode ( mncc_bearer_cap_cnf -> cause, | |
1865 &mncc_bearer_cap_cnf -> bcpara, | |
1866 &mncc_bearer_cap_cnf -> bcpara2 ); | |
1867 | |
1868 break; | |
1869 } | |
1870 break; | |
1871 | |
1872 #endif | |
1873 } | |
1874 | |
1875 /* | |
1876 *------------------------------------------------------------------- | |
1877 * free the primitive buffer | |
1878 *------------------------------------------------------------------- | |
1879 */ | |
1880 PFREE (mncc_bearer_cap_cnf); | |
1881 | |
1882 } | |
1883 | |
1884 /* | |
1885 +-------------------------------------------------------------------+ | |
1886 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
1887 | ROUTINE : psa_mncc_prompt_ind | | |
1888 +-------------------------------------------------------------------+ | |
1889 | |
1890 PURPOSE : processes the MNCC_PROMPT_IND primitive send by CC. | |
1891 this requests a transaction identifier for a CCBS recall. | |
1892 | |
1893 */ | |
1894 | |
1895 GLOBAL void psa_mncc_prompt_ind | |
1896 ( T_MNCC_PROMPT_IND *mncc_prompt_ind ) | |
1897 { | |
1898 SHORT ti; | |
1899 | |
1900 TRACE_FUNCTION ("psa_mncc_prompt_ind()"); | |
1901 | |
1902 /* | |
1903 *------------------------------------------------------------------- | |
1904 * allocate transaction identifier | |
1905 *------------------------------------------------------------------- | |
1906 */ | |
1907 ti = psaCC_getMOCTi( -1 ); | |
1908 | |
1909 if( ti NEQ -1 ) | |
1910 { | |
1911 PALLOC (mncc_prompt_res, MNCC_PROMPT_RES); | |
1912 mncc_prompt_res -> ti = (UBYTE)ti; | |
1913 PSENDX (CC, mncc_prompt_res); | |
1914 } | |
1915 else | |
1916 { | |
1917 PALLOC (mncc_prompt_rej, MNCC_PROMPT_REJ); | |
1918 PSENDX (CC, mncc_prompt_rej); | |
1919 } | |
1920 | |
1921 /* | |
1922 *------------------------------------------------------------------- | |
1923 * free the primitive buffer | |
1924 *------------------------------------------------------------------- | |
1925 */ | |
1926 PFREE (mncc_prompt_ind); | |
1927 | |
1928 } | |
1929 | |
1930 /* | |
1931 +-------------------------------------------------------------------+ | |
1932 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
1933 | ROUTINE : psa_mncc_recall_ind | | |
1934 +-------------------------------------------------------------------+ | |
1935 | |
1936 PURPOSE : processes the MNCC_RECALL_IND primitive send by CC. | |
1937 this indicates a recall attempt from the network in case | |
1938 of CCBS. | |
1939 | |
1940 */ | |
1941 | |
1942 GLOBAL void psa_mncc_recall_ind | |
1943 ( T_MNCC_RECALL_IND *mncc_recall_ind ) | |
1944 { | |
1945 SHORT cId; /* holds call table identifier */ | |
1946 T_CC_CALL_TBL * pCtbNtry; /* holds pointer to call table entry */ | |
1947 | |
1948 TRACE_FUNCTION ("psa_mncc_recall_ind()"); | |
1949 | |
1950 /* | |
1951 *------------------------------------------------------------------- | |
1952 * check for K.O. criteria | |
1953 *------------------------------------------------------------------- | |
1954 */ | |
1955 if( aoc_check_moc() EQ FALSE ) | |
1956 { | |
1957 PALLOC (mncc_reject_req, MNCC_REJECT_REQ); | |
1958 | |
1959 mncc_reject_req -> ti = mncc_recall_ind -> ti; | |
1960 mncc_reject_req -> cause = MNCC_CAUSE_ACM_MAX; | |
1961 | |
1962 PSENDX (CC, mncc_reject_req); | |
1963 } | |
1964 | |
1965 else if((cId = psaCC_ctbNewEntry()) < 0 ) | |
1966 { | |
1967 PALLOC (mncc_reject_req, MNCC_REJECT_REQ); | |
1968 | |
1969 mncc_reject_req -> ti = mncc_recall_ind -> ti; | |
1970 mncc_reject_req -> cause = MNCC_CAUSE_USER_BUSY; | |
1971 | |
1972 PSENDX (CC, mncc_reject_req); | |
1973 } | |
1974 | |
1975 /* | |
1976 *------------------------------------------------------------------- | |
1977 * insert recall parameters into call table entry | |
1978 *------------------------------------------------------------------- | |
1979 */ | |
1980 else | |
1981 { | |
1982 pCtbNtry = ccShrdPrm.ctb[cId]; | |
1983 | |
1984 pCtbNtry -> ti = mncc_recall_ind -> ti; | |
1985 pCtbNtry -> rptInd = mncc_recall_ind -> ri; | |
1986 | |
1987 /* | |
1988 * Assign called party | |
1989 */ | |
1990 pCtbNtry -> cldPty.ton = mncc_recall_ind -> called_party.ton; | |
1991 pCtbNtry -> cldPty.npi = mncc_recall_ind -> called_party.npi; | |
1992 pCtbNtry -> cldPty.c_called_num = | |
1993 mncc_recall_ind -> called_party.c_called_num; | |
1994 if (pCtbNtry -> cldPty.called_num NEQ NULL) | |
1995 { | |
1996 ACI_MFREE (pCtbNtry -> cldPty.called_num); | |
1997 pCtbNtry -> cldPty.called_num = NULL; | |
1998 } | |
1999 if (pCtbNtry -> cldPty.c_called_num NEQ 0) | |
2000 { | |
2001 ACI_MALLOC (pCtbNtry -> cldPty.called_num, | |
2002 pCtbNtry -> cldPty.c_called_num); | |
2003 memcpy (pCtbNtry -> cldPty.called_num, | |
2004 mncc_recall_ind -> called_party.called_num, | |
2005 mncc_recall_ind -> called_party.c_called_num); | |
2006 } | |
2007 | |
2008 /* | |
2009 * Assign called party subaddress | |
2010 */ | |
2011 pCtbNtry -> cldPtySub = mncc_recall_ind -> called_party_sub; | |
2012 | |
2013 /* | |
2014 * Assign bearer caps | |
2015 */ | |
2016 memcpy( &(pCtbNtry->BC[0]),&(mncc_recall_ind->bcpara), | |
2017 sizeof( T_MNCC_bcpara) ); | |
2018 memcpy( &(pCtbNtry->BC[1]),&(mncc_recall_ind->bcpara2), | |
2019 sizeof( T_MNCC_bcpara) ); | |
2020 | |
2021 psaCC_phbSrchNum( cId, CT_NI_MOC ); | |
2022 | |
2023 pCtbNtry -> calStat = CS_ACT_REQ; | |
2024 pCtbNtry -> calType = CT_NI_MOC; | |
2025 | |
2026 pCtbNtry -> prio = MNCC_PRIO_NORM_CALL; | |
2027 pCtbNtry -> curBC = 0; | |
2028 | |
2029 } | |
2030 | |
2031 /* | |
2032 *------------------------------------------------------------------- | |
2033 * free the primitive buffer | |
2034 *------------------------------------------------------------------- | |
2035 */ | |
2036 PFREE (mncc_recall_ind); | |
2037 | |
2038 } | |
2039 | |
2040 /* | |
2041 +-------------------------------------------------------------------+ | |
2042 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
2043 | ROUTINE : psa_mncc_status_ind | | |
2044 +-------------------------------------------------------------------+ | |
2045 | |
2046 PURPOSE : processes the MNCC_STATUS_IND primitive sent by CC. | |
2047 This indicates that a STATUS ENQUIRY message has been | |
2048 received by CC, the network awaits a CC STATUS message. | |
2049 Used to ensure that the auxiliary states between ACI and | |
2050 CC were synchronized before the STATUS message is sent. | |
2051 | |
2052 */ | |
2053 | |
2054 GLOBAL void psa_mncc_status_ind (T_MNCC_STATUS_IND *mncc_status_ind) | |
2055 { | |
2056 UBYTE ti; | |
2057 | |
2058 TRACE_FUNCTION ("psa_mncc_status_ind()"); | |
2059 | |
2060 ti = mncc_status_ind->ti; | |
2061 | |
2062 { | |
2063 PREUSE (mncc_status_ind, mncc_status_res, MNCC_STATUS_RES); | |
2064 mncc_status_res->ti = ti; | |
2065 PSENDX (CC, mncc_status_res); | |
2066 } | |
2067 } | |
2068 | |
2069 /* | |
2070 +-------------------------------------------------------------------+ | |
2071 | PROJECT : GSM-PS (6147) MODULE : PSA_CCP | | |
2072 | ROUTINE : psa_mncc_facility_ind | | |
2073 +-------------------------------------------------------------------+ | |
2074 | |
2075 PURPOSE : processes the MNCC_FACILITY_IND primitive send by CC. | |
2076 this indicates the receiving of a facility information | |
2077 element. Handles multiple components in the facility info. | |
2078 | |
2079 */ | |
2080 | |
2081 GLOBAL void psa_mncc_facility_ind(T_MNCC_FACILITY_IND * mncc_facility_ind) | |
2082 { | |
2083 UBYTE tlen = 0; | |
2084 USHORT offset_comp = 0, total_len = mncc_facility_ind->fac_inf.l_fac/8; | |
2085 UBYTE len_comp = 0; | |
2086 UBYTE *tPtrfac = mncc_facility_ind->fac_inf.fac; | |
2087 | |
2088 TRACE_FUNCTION ("psa_mncc_facility_ind()"); | |
2089 | |
2090 if (tPtrfac[1] > 0x7F)/* For the case, when length is coded in non-standard way (0x80, 0x81, 0x82) we will be able to process only one component */ | |
2091 { | |
2092 psaCC_ProcessCmp((T_MNCC_FACILITY_IND *)mncc_facility_ind); | |
2093 return; | |
2094 } | |
2095 | |
2096 offset_comp = mncc_facility_ind->fac_inf.o_fac; | |
2097 len_comp = tlen = tPtrfac[1] + 2; | |
2098 | |
2099 for ( ; total_len >= len_comp; len_comp+=tlen) | |
2100 { | |
2101 if ((*tPtrfac EQ 0xA1) OR | |
2102 (*tPtrfac EQ 0xA2) OR | |
2103 (*tPtrfac EQ 0xA3) OR | |
2104 (*tPtrfac EQ 0xA4)) | |
2105 { | |
2106 PALLOC(new_mncc_facility_ind, MNCC_FACILITY_IND); | |
2107 | |
2108 new_mncc_facility_ind->ti = mncc_facility_ind->ti; | |
2109 new_mncc_facility_ind->fac_context = mncc_facility_ind->fac_context; | |
2110 new_mncc_facility_ind->fac_inf.l_fac = tlen * 8; | |
2111 new_mncc_facility_ind->fac_inf.o_fac = offset_comp; | |
2112 memcpy(new_mncc_facility_ind->fac_inf.fac, tPtrfac, tlen); | |
2113 | |
2114 psaCC_ProcessCmp((T_MNCC_FACILITY_IND *)new_mncc_facility_ind); | |
2115 | |
2116 tPtrfac = tPtrfac + tlen; | |
2117 tlen = tPtrfac[1] + 2; | |
2118 offset_comp = 0; | |
2119 } | |
2120 } | |
2121 | |
2122 PFREE(mncc_facility_ind); | |
2123 } | |
2124 | |
2125 /*==== EOF =========================================================*/ |