FreeCalypso > hg > freecalypso-citrine

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

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 09 Jun 2016 00:02:41 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:75a11d740a02
1 /*
2 +-----------------------------------------------------------------------------
3 | Project : GSM-PS (6147)
4 | Modul : 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 =========================================================*/