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