FreeCalypso > hg > fc-magnetite

comparison src/aci2/mfw/mfw_cm.c @ 3:93999a60b835

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/aci2, src/condat2: import of g23m/condat source pieces from TCS211
author Mychaela Falconia <falcon@freecalypso.org>
date Mon, 26 Sep 2016 00:29:36 +0000
parents
children
comparison
equal deleted inserted replaced
2:c41a534f33c6 3:93999a60b835
1 /*
2 +--------------------------------------------------------------------+
3 | PROJECT: MMI-Framework (8417) $Workfile:: mfw_cm.c $|
4 | $Author:: Ak $Revision:: 1 $|
5 | CREATED: 3.11.98 $Modtime:: 10.04.00 14:58 $|
6 | STATE : code |
7 +--------------------------------------------------------------------+
8
9 MODULE : MFW_CM
10
11 PURPOSE : This modul contains call management functions.
12
13 HISTORY:
14
15 Mar 28, 2006 REF:DR OMAPS00072407 x0039928
16 Description: Phone hangs when tried to make an outgoing call
17 Solution: Reverting back the changes of issue OMAPS00048894 to stop from stack overflow.
18
19 Feb 27, 2006 REF:DR OMAPS00067884 x0039928
20 Description: Held call released at locosto phone does not release the call at other end
21 Solution: if the mode is greater than CHLD_MOD_RelDialCall then sAT_PercentCHLD() is called
22 instead of sAT_PlusCHLD()
23
24 Jan 27, 2006 REF:DR OMAPS00048894 x0039928
25 Description: Outgoing Call: The called number is not displayed while an outgoing call is made
26 Solution: The called number is extracted from the parameter of callCmEvent() for event E_CM_MO_RES and is displayed.
27
28 Sep 12, 2005 REF: MMI-SMR-34085 x0021334
29 Description: RE: Add +CDIP command - MMI Additions
30 Solution: Dummy implementation of function "rAT_PlusCDIP()" is done to enable successful compilation.
31 Nov 02, 2005 DR OMAPS00052132 xdeepadh
32 Bug:Not able to access the SMS inbox and also not able to send SMS in Locosto Lite build
33 Fix: The ATI Enums usage has been put under the FF_ATI flag.
34
35 Aug 10, 2005 REF: MMI-SPR-30099 x0018858
36 Description: During a held communication, if the user presses 4 and send then there is no response from network.
37 Solution: Modified the return value and also added a case statement to handle the response received.
38
39 Apr 07 2005 REF: CRR 29989 xpradipg
40 Description: Optimisation 3: replace the static global data with dynamic
41 allocation / deallocation
42 Solution: The static global variables are dynamically allocated and
43 deallocated
44
45 Apr 03, 2005 REF: CRR 29988 - xpradipg
46 Description: Optimisation 2: Reduce the keyboard buffer and the dtmf buffer
47 size
48 Solution : The dtmf buffer is reduced to 20 from 50
49
50 Apr 14, 2005 REF: CRR 29991 xpradipg
51 Description: Optimisation 5: Remove the static allocation and use dynamic
52 allocation/ deallocation for pb_list and black_list
53 Solution: The static definition is removed and replaced with the dynamic
54 allocation
55
56 Feb 03, 200 REF: CRR 25960 x0012850
57 Description: Call Hold: While one call in Active and other in Held by swapping either of phone is not audible
58 Solution: swapping action results in one of the calls getting muted. We attach user connection again.
59
60 Aug 23, 2004 REF: CRR 22222 xkundadu
61 Bug: Runaway Call Waiting Tone.
62 Call Waiting tone doesnot stop after ansering waiting call.
63
64 Fix: Handle the AT-Command source id CMD_SRC_ATI_2 also for call control
65 callback functions.
66
67 Jun 05, 2004 REF: CRR 18262 NISHIKANT KULKARNI
68 Description: The sample sends a STOP DTMF message without release of the key by the user
69 Solution: Instead of sending DTMF commands in "VTS_MOD_Auto" mode, on key press DTMF tone is started
70 using VTS_MOD_ManStart and on key release DTMF tone is stopped using VTS_MOD_ManStop mode.
71
72 // Apr 26, 2004 REF: CRR 16545 Ajith K P and Side effect of CRR 16545.
73 // Issue description: When the user enters 11SEND and if the first call is
74 // HELD call,the held call disconnects. This should not happen.
75 // Problem was, though sAT_PlusCHLD(..) is expected to disconnect an ACTIVE
76 // call only, it was disconnecting HELD call rather than returning AT_FAIL.
77 // If sAT_PlusCHLD() Fails, Send the user entered string as USSD to network using sAT-Dn().
78 // So now if the user wants to release a HELD call, in cm_disconect() we are calling the
79 // sAT_PlusCHLD(..) function with C
80
81 */
82
83 #define ENTITY_MFW
84
85 #include <string.h>
86 #include <stdio.h>
87 #include <stdlib.h>
88
89 #if defined (NEW_FRAME)
90
91 #include "typedefs.h"
92 #include "vsi.h"
93 #include "pei.h"
94 #include "custom.h"
95 #include "gsm.h"
96
97 #else
98
99 #include "STDDEFS.H"
100 #include "custom.h"
101 #include "gsm.h"
102 #include "vsi.h"
103
104 #endif
105
106
107 #include "mfw_mfw.h"
108 #include "mfw_phb.h"
109 #include "mfw_phbi.h"
110 #include "mfw_cm.h"
111 #include "mfw_cmi.h"
112 #include "mfw_nm.h"
113 #include "mfw_sim.h"
114 #include "mfw_sima.h"
115 #include "mfw_nmi.h"
116 #include "mfw_simi.h"
117 #include "mfw_win.h"
118
119 #include "mfw_tim.h"
120 #include "mfw_utils.h"
121
122 #include "ksd.h"
123 #include "psa.h"
124
125 #if defined (FAX_AND_DATA)
126 #include "aci_fd.h"
127 #endif
128
129 #include "cmh.h"
130 #include "phb.h"
131 #include "cmh_phb.h"
132
133 #include "mfw_ss.h"
134 #include "mfw_ssi.h"
135 #include "mfw_win.h"
136 #include "mfw_ffs.h"
137
138 #include "prim.h"
139 #ifndef PCM_2_FFS
140 #include "pcm.h"
141 #endif
142
143
144 /*
145 * Conditional compilation flag for CCBS testing.
146 * When defined, the cm_ccbs_... functions do not call ACI functions but
147 * simply set the return value variable to indicate success. Also the body
148 * of the rAT_PercentMMITEST function is defined for parsing AT%MMITEST
149 * commands and calling ACI/MFW functions as if CCBS events had occured.
150 */
151 // #define CCBS_TEST
152
153 /********* current define *******************************************/
154 // Apr 14, 2005 REF: CRR 29991 xpradipg
155 // remove the static definition
156 #ifndef FF_MMI_OPTIM
157 static T_MFW_CM_BLACKLIST_LIST black_list;
158 #endif
159
160 // Apr 06 2005 REF: CRR 29989 xpradipg
161 // The definition of global is removed since it is locally used
162 #ifndef FF_MMI_OPTIM
163 static T_ACI_CAL_ENTR call_tab[MAX_CALL_NR];
164 #endif
165 static T_MFW_PHB_LIST entries;
166 static T_MFW_CM_CC_STAT cc_stat; /* current outgoing call status */
167 static T_MFW_CM_COMMAND cmd;
168 static T_MFW_CM_NOTIFY notify;
169
170 static UBYTE call_type; /* indicate an ECC call or normal call */
171 static UBYTE call_stat; /* indicate an MO call or MT call */
172 static SHORT cc_id; /* current call index */
173 static UBYTE redial_stat;
174 static UBYTE redial_count;
175 static UBYTE cmd_hold;
176
177 static T_MFW_CM_CW_INFO in_call;
178 static T_MFW_CM_MO_INFO out_call;
179 static T_MFW_CM_DISCONNECT dis_connect;
180 static T_MFW_CM_REDIAL rdl;
181 static T_MFW_CM_CPI cm_cpi;
182 /* Marcus: CCBS: 14/11/2002: Start */
183 static T_MFW_CM_CCBS_INFO ccbs_info; // E_CM_CCBS data
184 static T_MFW_CM_CCBS_OP ccbs_op = CM_CCBS_NONE; // Current CCBS operation
185 /* Marcus: CCBS: 14/11/2002: End */
186
187 static T_CM_CLI cli_prefix;
188 /*CONQUEST 5998-MC 30/04/02 -initialised timers to zero (prevents corruption) */
189 static MfwHnd redialTim1= NULL; /* the 1th redialing */
190 static MfwHnd redialTim24 = NULL; /* the 2th to 4st redialing */
191 static MfwHnd redialTim5 = NULL; /* the 5th or over redialing */
192
193 static int cmCommand (U32 cmd, void *h); /* handle window commands */
194 static int cm_redial_timeout(MfwEvt e, MfwTim *t);
195 static char currAccepting = 0; /* ES!! 210999 */
196 static char currConnecting = 0; /* ES!! 290999 */
197 static T_ACI_AT_CMD currCmd;
198
199 void cm_force_disconnect(void); // RAVI
200
201 //APR 03 2005 - REF CRR: 29988 xpradipg
202 //The DTMF buffer is reduced from 50 to 20
203 #ifdef FF_MMI_REDUCED_KBD_BUFFER
204 #define MAX_DTMF_Q_ENTRIES 20
205 #else
206 #define MAX_DTMF_Q_ENTRIES 50
207 #endif
208 #define CPI_CAUSE_MASK 0xFF /* cq11676 cause mask 17-02-04 MZ */
209 static UBYTE dtmf_q[MAX_DTMF_Q_ENTRIES];
210 static SHORT mfw_cm_dtmf_q_id;
211 //xnkulkar 18262 This BOOL variable is used to determine whether we have received an
212 //acknowledegment for command sAT_PlusVTS() to start/stop the previous DTMF tone.
213 static BOOL expectRatOk = FALSE;
214
215 // MMI-SPR 13873 xkundadu.
216 // Added this boolean variable to check whether a particular call is in
217 // multiparty or not
218 BOOL bIsMultpty = FALSE;
219
220 EXTERN MfwHdr * current_mfw_elem;
221
222 LOCAL T_MFW_CM_CALL_STAT cm_cvt_call_status( T_ACI_CAL_STAT stat );
223
224
225 /*
226 +--------------------------------------------------------------------+
227 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
228 | STATE : code ROUTINE: cm_init |
229 +--------------------------------------------------------------------+
230
231
232 PURPOSE : initialize for call management
233
234 */
235
236 void cm_init(void)
237 {
238 // Apr 14, 2005 REF: CRR 29991 xpradipg
239 // local variable definition
240 #ifdef FF_MMI_OPTIM
241 T_MFW_CM_BLACKLIST_LIST black_list;
242 int8 file;
243 #endif
244 TRACE_FUNCTION ("cm_init()");
245 memset(&black_list, 0, sizeof(T_MFW_CM_BLACKLIST_LIST));
246 // Apr 14, 2005 REF: CRR 29991 xpradipg
247 // Since the blacklist is not persistent across powercycles we reset the file
248 // contents
249 #ifdef FF_MMI_OPTIM
250 if( flash_MMI_blackList_write((U8 *)&black_list, sizeof(T_MFW_CM_BLACKLIST_LIST),0) < 0)
251 TRACE_EVENT("Error opening the black list file");
252 #endif
253
254 currAccepting = 0; /* ES!! 210999 */
255 currConnecting = 0; /* ES!! 290999 */
256
257 call_type = MFW_CALL_FREE;
258 call_stat = MFW_CALL_FREE;
259 cc_stat.type = MFW_CALL_FREE;
260 cc_id = 0;
261
262 cmd_hold = 0;
263 currCmd = AT_CMD_NONE;
264
265 // get prefix from EEPROM
266 cli_prefix = 0;
267
268 /* create time event for redialing */
269 redialTim1 = timCreate (0, MIN_DURATION_1, (MfwCb)cm_redial_timeout);
270 redialTim24 = timCreate (0, MIN_DURATION_2_4, (MfwCb)cm_redial_timeout);
271 redialTim5 = timCreate (0, MIN_DURATION_5, (MfwCb)cm_redial_timeout);
272
273 redial_stat = (UBYTE)FFS_flashData.redial_mode;
274
275 mfwCommand[MfwTypCm] = (MfwCb) cmCommand;
276
277 /*
278 ** Create a static circular buffer to hold the dtmf tones
279 */
280 mfw_cm_dtmf_q_id = mfw_cbuf_create( MAX_DTMF_Q_ENTRIES,
281 sizeof(UBYTE),
282 0,
283 0xFF,
284 TRUE,
285 (void *)&dtmf_q[0]);
286
287 if (mfw_cm_dtmf_q_id < 0)
288 TRACE_EVENT_P1("ERROR : mfw_cbuf_create failed with error value %d", mfw_cm_dtmf_q_id);
289 }
290
291
292 /*
293 +--------------------------------------------------------------------+
294 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
295 | STATE : code ROUTINE: cm_exit |
296 +--------------------------------------------------------------------+
297
298
299 PURPOSE :
300
301 */
302
303 void cm_exit(void)
304 {
305 TRACE_FUNCTION ("cm_exit()");
306
307 /* delete time event for redialing */
308 timDelete (redialTim5);
309 timDelete (redialTim24);
310 timDelete (redialTim1);
311 }
312
313
314 /*
315 +--------------------------------------------------------------------+
316 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
317 | STATE : code ROUTINE: cm_create |
318 +--------------------------------------------------------------------+
319
320
321 PURPOSE : create event for call management
322
323 */
324
325 T_MFW_HND cm_create(T_MFW_HND hWin, T_MFW_EVENT event, T_MFW_CB cbfunc)
326 {
327 T_MFW_HDR *hdr;
328 T_MFW_CM *cm_para;
329
330 TRACE_FUNCTION ("cm_create()");
331
332 hdr = (T_MFW_HDR *) mfwAlloc(sizeof (T_MFW_HDR));
333 cm_para = (T_MFW_CM *) mfwAlloc(sizeof (T_MFW_CM));
334
335 if (!hdr OR !cm_para)
336 return FALSE;
337
338 /*
339 * initialisation of the handler
340 */
341 cm_para->emask = event;
342 cm_para->handler = cbfunc;
343
344 hdr->data = cm_para; /* store parameter in node */
345 hdr->type = MFW_TYP_CM; /* store type of event handler */
346
347 /*
348 * installation of the handler
349 */
350 return mfwInsert((T_MFW_HDR *)hWin, hdr);
351 }
352
353
354 /*
355 +--------------------------------------------------------------------+
356 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
357 | STATE : code ROUTINE: cm_delete |
358 +--------------------------------------------------------------------+
359
360
361 PURPOSE : delete a event for call management
362
363 */
364
365 T_MFW_RES cm_delete(T_MFW_HND h)
366 {
367 TRACE_FUNCTION ("cm_delete()");
368
369 if (!h OR !((T_MFW_HDR *)h)->data)
370 return MFW_RES_ILL_HND;
371
372 if (!mfwRemove((T_MFW_HDR *)h))
373 return MFW_RES_ILL_HND;
374
375 mfwFree((U8 *)(((T_MFW_HDR *) h)->data),sizeof(T_MFW_CM));
376 mfwFree((U8 *)h,sizeof(T_MFW_HDR));
377
378 return MFW_RES_OK;
379 }
380
381
382 /*
383 +--------------------------------------------------------------------+
384 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
385 | STATE : code ROUTINE: cm_signal |
386 +--------------------------------------------------------------------+
387
388 PURPOSE : send a event signal.
389
390 */
391
392 void cm_signal(T_MFW_EVENT event, void * para)
393 {
394 UBYTE temp;
395
396
397
398 temp = dspl_Enable(0);
399
400
401 if (mfwSignallingMethod EQ 0)
402 {
403 /*
404 * focus is on a window
405 */
406 if (mfwFocus)
407 /*
408 * send event to sim management
409 * handler if available
410 */
411 if (cm_sign_exec (mfwFocus, event, para))
412 {
413 dspl_Enable(temp);
414 return;
415 }
416
417 /*
418 * acutal focussed window is not available
419 * or has no network management registration
420 * handler, then search all nodes from the root.
421 */
422 if (mfwRoot)
423 cm_sign_exec (mfwRoot, event, para);
424 }
425 else
426 {
427 MfwHdr * h = 0;
428
429 /*
430 * Focus set, then start here
431 */
432 if (mfwFocus)
433 h = mfwFocus;
434 /*
435 * Focus not set, then start root
436 */
437 if (!h)
438 h = mfwRoot;
439
440 /*
441 * No elements available, return
442 */
443
444 while (h)
445
446
447 {
448 /*
449 * Signal consumed, then return
450 */
451 if (cm_sign_exec (h, event, para))
452 {
453 dspl_Enable(temp);
454 return;
455 }
456
457 /*
458 * All windows tried inclusive root
459 */
460 if (h == mfwRoot)
461 {
462 dspl_Enable(temp);
463 return;
464 }
465
466 /*
467 * get parent window
468 */
469 h = mfwParent(mfwParent(h));
470 if(h)
471 h = ((MfwWin * )(h->data))->elems;
472 }
473 cm_sign_exec (mfwRoot, event, para);
474 }
475 dspl_Enable(temp);
476 }
477
478 /*
479 +--------------------------------------------------------------------+
480 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
481 | STATE : code ROUTINE: cm_sign_exec |
482 +--------------------------------------------------------------------+
483
484
485 PURPOSE : Send a signal if CM management handler.
486
487 */
488
489 BOOL cm_sign_exec (T_MFW_HDR * cur_elem, T_MFW_EVENT event, T_MFW_CM_PARA * para)
490 {
491 TRACE_FUNCTION ("cm_sign_exec()");
492
493 while (cur_elem)
494 {
495 /*
496 * event handler is available
497 */
498 if (cur_elem->type EQ MFW_TYP_CM)
499 {
500 T_MFW_CM * cm_data;
501 /*
502 * handler is CM management handler
503 */
504 cm_data = (T_MFW_CM *)cur_elem->data;
505 if (cm_data->emask & event)
506 {
507 /*
508 * event is expected by the call back function
509 */
510 cm_data->event = event;
511 switch (event)
512 {
513 case E_CM_COLP:
514 memcpy (&cm_data->para.mo_data, para, sizeof (T_MFW_CM_MO_INFO));
515 break;
516
517 case E_CM_DISCONNECT:
518 memcpy (&cm_data->para.disconnect, para, sizeof (T_MFW_CM_DISCONNECT));
519 break;
520 case E_CM_DISCONNECT_ALL:
521 memcpy (&cm_data->para.disconnect_all, para, sizeof (T_MFW_CM_DISCONNECT_ALL));
522 break;
523
524 case E_CM_CW:
525 memcpy (&cm_data->para.cw_info, para, sizeof (T_MFW_CM_CW_INFO));
526 break;
527
528 case E_CM_COMMAND:
529 memcpy (&cm_data->para.command, para, sizeof (T_MFW_CM_COMMAND));
530 break;
531
532 case E_CM_AOC:
533 memcpy (&cm_data->para.aoc_info, para, sizeof (T_MFW_CM_AOC_INFO));
534 break;
535
536 case E_CM_REDIAL:
537 memcpy (&cm_data->para.rdl, para, sizeof (T_MFW_CM_REDIAL));
538 break;
539
540 case E_CM_CONNECT_ACK:
541 memcpy (&cm_data->para.call_id, para, sizeof (SHORT));
542 break;
543
544 case E_CM_MO_RES:
545 memcpy (&cm_data->para.call_id, para, sizeof (SHORT));
546 break;
547
548 case E_CM_CPI:
549 memcpy (&cm_data->para.cm_cpi, para, sizeof (T_MFW_CM_CPI));
550 break;
551
552 case E_CM_RING_OFF:
553 break;
554
555 case E_CM_AOC_CNF:
556 memcpy (&cm_data->para.aoc_cnf, para, sizeof (T_MFW_CM_AOC_CNF));
557 break;
558
559 case E_CM_DTMF:
560 memcpy (&cm_data->para.dtmf_tone, para, sizeof (UBYTE));
561 break;
562
563 case E_CM_NOTIFY:
564 memcpy (&cm_data->para.notify, para, sizeof (T_MFW_CM_NOTIFY));
565 break;
566 /*MC SPR 1392*/
567 case E_CM_CALL_DEFLECT_STATUS:
568 memcpy (&cm_data->para.call_deflect_status, para, sizeof (BOOL));
569 break;
570 /* Marcus: CCBS: 14/11/2002: Start */
571 case E_CM_CCBS:
572 TRACE_EVENT("E_CM_CCBS");
573 memcpy (&cm_data->para.ccbs, para, sizeof (T_MFW_CM_CCBS_INFO));
574 break;
575 /* Marcus: CCBS: 14/11/2002: End */
576
577 case E_CM_CTYI:
578 memcpy (&cm_data->para.ctyi, para, sizeof (T_MFW_CM_CTYI));
579 break;
580
581 }
582
583 /*
584 * if call back defined, call it
585 */
586 if (cm_data->handler)
587 {
588 // PATCH LE 06.06.00
589 // store current mfw elem
590 current_mfw_elem = cur_elem;
591 // END PATCH LE 06.06.00
592 if ((*(cm_data->handler)) (cm_data->event, (void *)&cm_data->para))
593 return TRUE;
594 }
595 }
596 }
597 cur_elem = cur_elem->next;
598 }
599 return FALSE;
600 }
601
602
603 /*
604 +--------------------------------------------------------------------+
605 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
606 | STATE : code ROUTINE : cm_callTyp_cvt |
607 +--------------------------------------------------------------------+
608
609
610 PURPOSE : This function is used to convert the type of call class
611 used by MFW to the type of call class used by ACI.
612
613 */
614
615 LOCAL T_MFW_CM_CALL_TYPE cm_callTyp_cvt(T_ACI_CLASS cls)
616 {
617 switch ( cls )
618 {
619 case ( CLASS_Vce ) : return VOICE_CALL;
620 case ( CLASS_AuxVce): return AuxVOICE_CALL;
621 case ( CLASS_Dat ) : return DATA_CALL;
622 case ( CLASS_Fax ) : return FAX_CALL;
623 case ( CLASS_VceDat ) :
624 case ( CLASS_VceFax ) :
625 case ( CLASS_DatFax ) :
626 case ( CLASS_VceDatFax ): return (T_MFW_CM_CALL_TYPE)cls;
627 case ( CLASS_None ) : return NONE_TYPE;
628 case (CLASS_NotPresent): return NONE_TYPE;
629
630 default: return NONE_TYPE;
631 }
632 }
633
634
635 /*
636 +--------------------------------------------------------------------+
637 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
638 | STATE : code ROUTINE: cm_search_callId |
639 +--------------------------------------------------------------------+
640
641
642 PURPOSE : find call index from call table
643
644 */
645
646 int cm_search_callId(T_ACI_CAL_STAT type, SHORT *id)
647 {
648 int i;
649 // Apr 06 2005 REF: CRR 29989 xpradipg
650 // Local definition and allocation
651 #ifdef FF_MMI_OPTIM
652 T_ACI_CAL_ENTR *call_tab;
653 *id = 0;
654 call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
655 if(NULL == call_tab)
656 return CM_ERROR;
657 #else
658 *id = 0;
659 #endif
660 TRACE_FUNCTION("cm_search_callId()");
661
662
663 if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) != AT_CMPL)
664 {
665 // Apr 06 2005 REF: CRR 29989 xpradipg
666 // deallocation of memory allocated
667 #ifdef FF_MMI_OPTIM
668 if(call_tab)
669 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
670 #endif
671 return CM_ERROR;
672 }
673
674 for (i=0; i<MAX_CALL_NR; i++)
675 {
676 if (call_tab[i].index == -1)
677 break;
678
679 if (call_tab[i].status == type)
680 {
681 *id = call_tab[i].index;
682 // Apr 06 2005 REF: CRR 29989 xpradipg
683 // deallocation of memory
684 #ifdef FF_MMI_OPTIM
685 if(call_tab)
686 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
687 #endif
688 return CM_OK;
689 }
690
691 }
692 // Apr 06 2005 REF: CRR 29989 xpradipg
693 // deallocation of memory
694 #ifdef FF_MMI_OPTIM
695 if(call_tab)
696 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
697 #endif
698 return CM_ERROR;
699 }
700
701 /*
702 +--------------------------------------------------------------------+
703 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
704 | STATE : code ROUTINE: cm_search_callMode |
705 +--------------------------------------------------------------------+
706
707
708 PURPOSE : find call type from call table
709
710 */
711
712 T_ACI_CAL_MODE cm_search_callMode(SHORT id)
713 {
714 int i;
715 // Apr 06 2005 REF: CRR 29989 xpradipg
716 // allocation of memory, if the memory allocation fails then we return the
717 // error value same as when the qAT_PercentCAL() fails
718 #ifdef FF_MMI_OPTIM
719 T_ACI_CAL_ENTR *call_tab;//[MAX_CALL_NR];
720 T_ACI_CAL_MODE calMode;
721 call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
722 if(NULL == call_tab)
723 return CAL_MODE_Unknown;
724 #endif
725
726 TRACE_FUNCTION("cm_search_callMode()");
727
728 if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) != AT_CMPL)
729 {
730 // Apr 06 2005 REF: CRR 29989 xpradipg
731 // deallocate memory
732 #ifdef FF_MMI_OPTIM
733 if(call_tab)
734 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
735 #endif
736 return CAL_MODE_Unknown;
737 }
738 for (i=0; i<MAX_CALL_NR; i++)
739 {
740 if (call_tab[i].index == -1)
741 break;
742
743 if (call_tab[i].index == id)
744 {
745 // Apr 06 2005 REF: CRR 29989 xpradipg
746 // deallocate memory
747 #ifdef FF_MMI_OPTIM
748 calMode = call_tab[i].calMode;
749 if(call_tab)
750 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
751 return calMode;
752 #else
753 return call_tab[i].calMode;
754 #endif
755 }
756 }
757 // Apr 06 2005 REF: CRR 29989 xpradipg
758 // deallocate memory
759 #ifdef FF_MMI_OPTIM
760 if(call_tab)
761 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
762 #endif
763 return CAL_MODE_Unknown;
764 }
765
766 /*
767 +--------------------------------------------------------------------+
768 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
769 | STATE : code ROUTINE: cm_search_mptyId |
770
771
772 PURPOSE : find multiparty call index from call table
773
774 */
775
776 int cm_search_mptyId(T_ACI_CAL_MPTY type, SHORT *id)
777 {
778 int i;
779 // Apr 06 2005 REF: CRR 29989 xpradipg
780 // allocate memory
781 #ifdef FF_MMI_OPTIM
782 T_ACI_CAL_ENTR *call_tab;//[MAX_CALL_NR];
783 call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
784 if( NULL == call_tab)
785 return CM_ERROR;
786 #endif
787
788 TRACE_FUNCTION("cm_search_mptyId()");
789 *id = 0;
790
791 if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) != AT_CMPL)
792 {
793 // Apr 06 2005 REF: CRR 29989 xpradipg
794 // deallocate memory
795 #ifdef FF_MMI_OPTIM
796 if(call_tab)
797 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
798 #endif
799 return CM_ERROR;
800 }
801 for (i=0; i<MAX_CALL_NR; i++)
802 {
803 if (call_tab[i].index == -1)
804 break;
805
806 if (call_tab[i].mpty == type)
807 {
808 *id = call_tab[i].index;
809 // Apr 06 2005 REF: CRR 29989 xpradipg
810 // deallocate memory
811 #ifdef FF_MMI_OPTIM
812 if(call_tab)
813 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
814 #endif
815 return CM_OK;
816 }
817 }
818 // Apr 06 2005 REF: CRR 29989 xpradipg
819 // deallocate memory
820 #ifdef FF_MMI_OPTIM
821 if(call_tab)
822 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
823 #endif
824 return CM_ERROR;
825 }
826
827
828 /*
829 +-------------------------------------------------------------------+
830 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
831 | STATE : code ROUTINE: cm_search_numId |
832 +-------------------------------------------------------------------+
833
834
835 PURPOSE : find call index from call table
836
837 */
838
839 LOCAL SHORT cm_search_numId(UBYTE *number)
840 {
841 int i;
842 // Apr 06 2005 REF: CRR 29989 xpradipg
843 // allocate memory
844 #ifdef FF_MMI_OPTIM
845 SHORT index;
846 T_ACI_CAL_ENTR *call_tab;//[MAX_CALL_NR];
847 call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
848 if(NULL == call_tab)
849 return 0;
850 #endif
851
852 TRACE_FUNCTION("cm_search_numId()");
853
854 if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) != AT_CMPL)
855 {
856 // Apr 06 2005 REF: CRR 29989 xpradipg
857 // deallocate memory
858 #ifdef FF_MMI_OPTIM
859 if(call_tab)
860 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
861 #endif
862 return 0;
863 }
864
865 for (i=0; i<MAX_CALL_NR; i++)
866 {
867 if (call_tab[i].index == -1)
868 break;
869
870 if (!strcmp(call_tab[i].number, (char *)number))
871 {
872 // Apr 06 2005 REF: CRR 29989 xpradipg
873 // deallocate memory
874 #ifdef FF_MMI_OPTIM
875 index = call_tab[i].index;
876 if(call_tab)
877 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
878 return index;
879 #else
880 return call_tab[i].index;
881 #endif
882 }
883 }
884 // Apr 06 2005 REF: CRR 29989 xpradipg
885 // deallocate memory
886 #ifdef FF_MMI_OPTIM
887 if(call_tab)
888 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
889 #endif
890 return 0;
891 }
892
893
894 /*
895 +--------------------------------------------------------------------+
896 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
897 | STATE : code ROUTINE: cm_search_callStat |
898 +--------------------------------------------------------------------+
899
900
901 PURPOSE : Search the information from call table.
902
903 */
904
905 T_MFW cm_search_callStat(SHORT call_number,
906 T_MFW_CM_CALL_STAT *stat,
907 UBYTE *ton,
908 UBYTE *mode)
909 {
910 int i;
911 // Apr 06 2005 REF: CRR 29989 xpradipg
912 // allocat memory
913 #ifdef FF_MMI_OPTIM
914 T_ACI_CAL_ENTR *call_tab;//[MAX_CALL_NR];
915 call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
916 if( NULL == call_tab)
917 return CM_ERROR;
918 #endif
919
920 if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) EQ AT_CMPL)
921 {
922 for (i=0; i<MAX_CALL_NR; i++)
923 {
924 if (call_tab[i].index == -1)
925 break;
926
927 if (call_tab[i].index == call_number)
928 {
929 *stat = cm_cvt_call_status(call_tab[i].status);
930 *ton = phb_cvtTon(call_tab[i].type.ton);
931 *mode = cm_cvt_call_mode(call_tab[i].calMode);
932 // Apr 06 2005 REF: CRR 29989 xpradipg
933 // deallocate memory
934 #ifdef FF_MMI_OPTIM
935 if(call_tab)
936 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
937 #endif
938
939 return CM_OK;
940 }
941 }
942 // Apr 06 2005 REF: CRR 29989 xpradipg
943 // this will be returned once we get out of the if statement
944 #ifndef FF_MMI_OPTIM
945 return CM_ERROR;
946 #endif
947 }
948 // Apr 06 2005 REF: CRR 29989 xpradipg
949 // deallocate memory
950 #ifdef FF_MMI_OPTIM
951 if(call_tab)
952 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
953 #endif
954 return CM_ERROR;
955 }
956
957
958 /*
959 +--------------------------------------------------------------------+
960 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
961 | STATE : code ROUTINE: cm_check_emergency |
962 +--------------------------------------------------------------------+
963
964
965 PURPOSE : Check emergency call number
966
967 */
968
969 T_MFW cm_check_emergency(UBYTE *number)
970 {
971 //UBYTE index; // RAVI
972 // T_MFW_PHB_TEXT findText; // RAVI
973 // T_MFW_PHB_ENTRY entry; // RAVI
974
975 TRACE_FUNCTION ("cm_check_emergency()");
976 TRACE_EVENT_P1("String being passed = %s", (char*)number);
977
978 if (strlen((char *)number) <= 0 OR strlen((char *)number) > 3)
979 return FALSE;
980
981 if(psaCC_phbSrchECC((char*)number, FALSE))
982 {
983 TRACE_EVENT("psaCC_phbSrchECC - returned - TRUE");
984 return TRUE;
985 }
986 else
987 {
988 TRACE_EVENT("psaCC_phbSrchECC - returned - FALSE");
989 return FALSE;
990 }
991
992 }
993
994 /*
995 +--------------------------------------------------------------------+
996 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
997 | STATE : code ROUTINE: cm_mo_prefix |
998 +--------------------------------------------------------------------+
999
1000
1001 PURPOSE : set/get CLIP, CLIR, COLP and COLR tempstatus
1002
1003 */
1004
1005 T_CM_CLI cm_mo_prefix(T_CM_CLI prefix)
1006 {
1007 UBYTE bits;
1008
1009 if ((bits = (prefix & 0x0c)) != 0)
1010 cli_prefix = (cli_prefix & 0xf3) | bits;
1011 if ((bits = (prefix & 0xc0)) != 0)
1012 cli_prefix = (cli_prefix & 0x3f) | bits;
1013 return cli_prefix;
1014 }
1015
1016
1017 /*
1018 +--------------------------------------------------------------------+
1019 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
1020 | STATE : code ROUTINE: cm_set_cmd_status |
1021 +--------------------------------------------------------------------+
1022
1023
1024 PURPOSE :
1025
1026 */
1027
1028 void cm_set_cmd_status(T_ACI_CHLD_MOD mode, CHAR* call)
1029 {
1030 SHORT id;
1031 // Added xkundadu MMI-SPR 13873
1032 // Stores the status of a particular call.
1033 T_MFW_CM_STATUS status;
1034
1035 TRACE_FUNCTION("cm_set_cmd_status()"); // Marcus: CCBS: 14/11/2002
1036
1037 memset(&dis_connect, 0, sizeof(T_MFW_CM_DISCONNECT));
1038 memset(&cmd, 0, sizeof(T_MFW_CM_COMMAND));
1039 switch (mode)
1040 {
1041 case CHLD_MOD_RelHldOrUdub:
1042 TRACE_EVENT("CHLD_MOD_RelHldOrUdub"); // Marcus: CCBS: 14/11/2002
1043 /*SPR#1965 - DS - Changed from MFW_CM_MT_REJECT to MFW_CM_TERMINATED because
1044 * the E_CM_DISCONNECT signal is not sent in cm_ok_disconnect() if cmd_hold = MFW_CM_MT_REJECT.
1045 * Port of 1962.
1046 */
1047 cmd_hold = MFW_CM_TERMINATED;
1048
1049 if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)
1050 {
1051 TRACE_EVENT("cm_search_callId(CAL_STAT_Wait, &id) == CM_OK"); // Marcus: CCBS: 14/11/2002
1052 dis_connect.call_number = id;
1053 }
1054 else
1055 {
1056 TRACE_EVENT("cm_search_callId(CAL_STAT_Wait, &id) != CM_OK"); // Marcus: CCBS: 14/11/2002
1057 dis_connect.call_number = -1; // call id?
1058 }
1059
1060 break;
1061 case CHLD_MOD_RelActAndAcpt:
1062
1063 TRACE_EVENT("CHLD_MOD_RelActAndAcpt"); // Marcus: CCBS: 14/11/2002
1064 cmd_hold = MFW_CM_1_SEND;
1065
1066 // Added xkundadu MMI-SPR 13873
1067 // Querying if there are any active calls, storing the index of the
1068 // call and setting a flag if found to be multiparty.
1069 if (cm_search_callId(CAL_STAT_Active, &id) == CM_OK)
1070 {
1071 // Active call is present.
1072 dis_connect.call_number = id; // call id ?
1073 cm_status(id, &status, 1);
1074 if (status.mtpy EQ MFW_MTPY_MEMBER)
1075 {
1076 bIsMultpty = TRUE;
1077 }
1078 else
1079 {
1080 bIsMultpty = FALSE;
1081 }
1082
1083 }
1084 else
1085 {
1086 dis_connect.call_number = -1;
1087 }
1088 // Added xkundadu MMI-SPR 13873
1089 // Querying if there are any held calls, storing the index of the call
1090 // to change the status to active call.
1091 if (cm_search_callId(CAL_STAT_Held, &id) == CM_OK)
1092 {
1093 cmd.command = CM_RETRIEVE;
1094 cmd.call_number = id;
1095 }
1096 // Added xkundadu MMI-SPR 13873
1097 // Checking is there any waiting call exists or not.
1098 if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)
1099 {
1100 // This variable determines whether to accept/reject the call
1101 // in the cm_result_cmd().
1102 cmd.call_number=0;
1103 }
1104 else
1105 {
1106 cmd.call_number=-1;
1107 }
1108
1109 break;
1110
1111 case CHLD_MOD_RelActSpec:
1112 TRACE_EVENT("CHLD_MOD_RelActSpec"); // Marcus: CCBS: 14/11/2002
1113 dis_connect.call_number = (SHORT)atoi(call);
1114 if (dis_connect.call_number)
1115 {
1116 TRACE_EVENT("dis_connect.call_number"); // Marcus: CCBS: 14/11/2002
1117 cmd_hold = MFW_CM_TERMINATED;
1118 }
1119 else
1120 {
1121 TRACE_EVENT("!dis_connect.call_number"); // Marcus: CCBS: 14/11/2002
1122 cmd_hold = MFW_CM_MPTY_TERMINATED;
1123 }
1124 break;
1125 case CHLD_MOD_HldActAndAcpt:
1126 TRACE_EVENT("CHLD_MOD_HldActAndAcpt"); // Marcus: CCBS: 14/11/2002
1127 if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)
1128 {
1129 TRACE_EVENT("cm_search_callId(CAL_STAT_Wait, &id) == CM_OK"); // Marcus: CCBS: 14/11/2002
1130 cmd_hold = MFW_CM_MT_ACCEPT;
1131 /*
1132 * initialize for result event
1133 */
1134 cmd.command = CM_HOLD;
1135 cc_id = id;
1136 }
1137 else
1138 {
1139 TRACE_EVENT("cm_search_callId(CAL_STAT_Wait, &id) != CM_OK"); // Marcus: CCBS: 14/11/2002
1140 if ((cm_search_callId(CAL_STAT_Active, &id) == CM_OK)
1141 AND (cm_search_callId(CAL_STAT_Held, &id) == CM_OK))
1142 {
1143 TRACE_EVENT("cmd.command = CM_SWAP"); // Marcus: CCBS: 14/11/2002
1144 cmd.command = CM_SWAP;
1145 }
1146 if ((cm_search_callId(CAL_STAT_Active, &id) != CM_OK)
1147 AND (cm_search_callId(CAL_STAT_Held, &id) == CM_OK))
1148 {
1149 TRACE_EVENT("cmd.command = CM_RETRIEVE"); // Marcus: CCBS: 14/11/2002
1150 cmd.command = CM_RETRIEVE;
1151 }
1152 if ((cm_search_callId(CAL_STAT_Active, &id) == CM_OK)
1153 AND (cm_search_callId(CAL_STAT_Held, &id) != CM_OK))
1154 {
1155 TRACE_EVENT("cmd.command = CM_HOLD"); // Marcus: CCBS: 14/11/2002
1156 cmd.command = CM_HOLD;
1157 }
1158 cmd.call_number = 0;
1159 }
1160 break;
1161 case CHLD_MOD_HldActExc:
1162 TRACE_EVENT("CHLD_MOD_HldActExc"); // Marcus: CCBS: 14/11/2002
1163 cmd.command = CM_SPLIT_MULTIPARTY;
1164 cmd.call_number = 0;
1165 break;
1166 case CHLD_MOD_AddHld:
1167 TRACE_EVENT("CHLD_MOD_AddHld"); // Marcus: CCBS: 14/11/2002
1168 cmd.command = CM_BUILD_MULTIPARTY;
1169 cmd.call_number = 0;
1170 break;
1171 case CHLD_MOD_Ect:
1172 TRACE_EVENT("CHLD_MOD_Ect"); // Marcus: CCBS: 14/11/2002
1173 cmd.command = CM_ETC;
1174 cmd.call_number = 0;
1175 break;
1176 case CHLD_MOD_Ccbs:
1177 TRACE_EVENT("CHLD_MOD_Ccbs"); // Marcus: CCBS: 14/11/2002
1178 cmd.command = CM_CCBS;
1179 cmd.call_number = 0;
1180 break;
1181 case CHLD_MOD_HldActDial:
1182 TRACE_EVENT("CHLD_MOD_HldActDial"); // Marcus: CCBS: 14/11/2002
1183 cmd_hold = MFW_CM_HOLD_AND_DIAL;
1184 /*
1185 * initialize for result event
1186 */
1187 cmd.command = CM_HOLD;
1188 cc_id = id;
1189 break;
1190 }
1191 }
1192
1193
1194 /*
1195 +--------------------------------------------------------------------+
1196 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
1197 | STATE : code ROUTINE: cm_check_mo_number |
1198 +--------------------------------------------------------------------+
1199
1200
1201 PURPOSE : start mobile originated call
1202
1203 */
1204
1205 T_MFW cm_check_mo_number(UBYTE *number)
1206 {
1207 UBYTE i;
1208 // Apr 14, 2005 REF: CRR 29991 xpradipg
1209 // local definition
1210 #ifdef FF_MMI_OPTIM
1211 UBYTE count = 0;
1212 UBYTE blackListNum[MFW_NUM_LEN];
1213 int8 file;
1214 #endif
1215
1216 /* check whether a redialing exists */
1217 if (call_stat EQ REDIALING_CALL)
1218 {
1219 cm_stop_redialTim();
1220 rdl.redial_mode = CM_REDIAL_OUTGOING;
1221 cm_signal(E_CM_REDIAL, &rdl);
1222 }
1223
1224
1225 if (!number)
1226 return CM_OK;
1227 // Apr 14, 2005 REF: CRR 29991 xpradipg
1228 // the list is read from the file
1229 #ifdef FF_MMI_OPTIM
1230 if(( file = flash_MMI_blackList_open()) > 0)
1231 {
1232 if(flash_MMI_blackList_read(file,(U8*)&count,1,0) > 0)
1233 {
1234 for(i=0; i < (int)count; i++)
1235 {
1236 if(flash_MMI_blackList_read(file,(U8*)blackListNum,MFW_NUM_LEN,(i*MFW_NUM_LEN)+1) > 0)
1237 {
1238 if(!strcmp((char*)blackListNum, (char*)number))
1239 {
1240 flash_MMI_blackList_close(file);
1241 return CM_BLACKLIST;
1242 }
1243 }
1244 }
1245 }
1246 flash_MMI_blackList_close(file);
1247 }
1248 #else
1249 /* check whether this number is in blacklist */
1250 for (i=0; i<black_list.count; i++)
1251 {
1252 if (!strcmp((char *)black_list.number[i], (char *)number))
1253 return CM_BLACKLIST;
1254 }
1255 #endif
1256
1257 /* check the type of this number */
1258 if (cm_check_emergency(number) EQ TRUE)
1259 call_type = MFW_ECC_CALL;
1260 else
1261 call_type = MFW_NORMAL_CALL;
1262
1263 return CM_OK;
1264 }
1265
1266 /*
1267 +--------------------------------------------------------------------+
1268 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
1269 | STATE : code ROUTINE: cm_set_call_mode |
1270 +--------------------------------------------------------------------+
1271
1272
1273 PURPOSE : set call mode
1274
1275 */
1276
1277 void cm_set_call_mode(T_MFW_CM_CALL_TYPE mode)
1278 {
1279 switch (mode)
1280 {
1281 case VOICE_CALL:
1282 case AuxVOICE_CALL: /*MC, SPR 1026, assume line 2 is handled like line 1*/
1283 case DATA_CALL:
1284 case FAX_CALL:
1285 sAT_PlusCMOD(CMD_SRC_LCL, CMOD_MOD_Single);
1286 break;
1287 case VFD_VOICE:
1288 case VFD_DATA:
1289 sAT_PlusCMOD(CMD_SRC_LCL, CMOD_MOD_VoiceFlwdDat);
1290 break;
1291 case VAD_VOICE:
1292 case VAD_DATA:
1293 sAT_PlusCMOD(CMD_SRC_LCL, CMOD_MOD_VoiceDat);
1294 break;
1295 case VAF_VOICE:
1296 case VAF_FAX:
1297 sAT_PlusCMOD(CMD_SRC_LCL, CMOD_MOD_VoiceFax);
1298 break;
1299 default:
1300 break;
1301 }
1302 }
1303
1304 /*
1305 +--------------------------------------------------------------------+
1306 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
1307 | STATE : code ROUTINE: cm_mo_idx |
1308 +--------------------------------------------------------------------+
1309
1310
1311 PURPOSE : start mobile originated call
1312
1313 */
1314
1315 T_MFW cm_mo_idx(T_KSD_SEQPARAM *para, T_MFW_CM_CALL_TYPE mode)
1316 {
1317 T_MFW_PHB_LIST entries;
1318 T_MFW_PHB_ENTRY entry;
1319 UBYTE res;
1320
1321 //RM 19_09_2000
1322 #ifdef NO_ASCIIZ
1323 T_ACI_PB_TEXT mfwpbText;
1324 #endif
1325 //RM
1326
1327 entries.entry = &entry;
1328
1329 /* search this number from phonebook */
1330 if ((phb_read_entries(PHB_ADN, (UBYTE)para->dialIdx.index,
1331 MFW_PHB_INDEX, 1,
1332 &entries) EQ MFW_PHB_OK)
1333 AND ((int)entries.num_entries > 0))
1334 {
1335 res = cm_check_mo_number(entries.entry->number);
1336 if (res NEQ CM_OK)
1337 return res;
1338 }
1339 else
1340 {
1341 res = cm_check_mo_number(0);
1342 if (res NEQ CM_OK)
1343 return res;
1344 }
1345
1346 /* set the outgoing call status */
1347 call_stat = OUTGOING_CALL;
1348 redial_count = 0;
1349 cc_stat.type = OUTGOING_CALL;
1350
1351 cm_set_call_mode(mode);
1352
1353 //RM 19_09_2000 instead change in ksd structure T_KSD_SEQPARAM etc., later to change !!!!
1354 #ifdef NO_ASCIIZ
1355 if(para->dialIdx.str NEQ NULL)
1356 {
1357 mfwpbText.cs = CS_GsmDef;
1358 mfwpbText.len = strlen(para->dialIdx.str);
1359 memcpy(mfwpbText.data,para->dialIdx.str,mfwpbText.len);
1360 }
1361 else
1362 {
1363 mfwpbText.cs = CS_NotPresent;
1364 mfwpbText.len = 0;
1365 }
1366 res = sAT_Dm(CMD_SRC_LCL, &mfwpbText,
1367 para->dialIdx.mem, para->dialIdx.index,
1368 para->dialIdx.clirOvrd, para->dialIdx.cugCtrl,
1369 para->dialIdx.callType);
1370 #else
1371 res = sAT_Dm(CMD_SRC_LCL, para->dialIdx.str,
1372 para->dialIdx.mem, para->dialIdx.index,
1373 para->dialIdx.clirOvrd, para->dialIdx.cugCtrl,
1374 para->dialIdx.callType);
1375 #endif
1376
1377 if ((res == AT_FAIL) OR (res == AT_BUSY))
1378 {
1379 call_stat = MFW_CALL_FREE;
1380 return cm_error_code(AT_CMD_D);
1381 }
1382
1383 return CM_OK;
1384 }
1385
1386 /*
1387 +--------------------------------------------------------------------+
1388 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
1389 | STATE : code ROUTINE: cm_mo_call |
1390 +--------------------------------------------------------------------+
1391
1392
1393 PURPOSE : start mobile originated call
1394
1395 */
1396
1397 T_MFW cm_mo_call(UBYTE *number, T_MFW_CM_CALL_TYPE type)
1398 {
1399 CHAR * rest;
1400 T_KSD_SEQPARAM para;
1401 T_MFW_SS_RETURN typ;
1402 T_MFW_SS_RETURN new_typ;
1403 CHAR * string;
1404 UBYTE cm_grp = 0; // RAVI
1405 UBYTE clir_status;
1406 UBYTE colr_status;
1407 UBYTE prefix;
1408 char buf[80];
1409 UBYTE phone[MFW_NUM_LEN];
1410 UBYTE num_save[MFW_STRING_LEN];
1411 SHORT id;
1412 T_ACI_RETURN res,aci_result;//aci_result was added to fix the bug MMI-SPR 16545
1413
1414 TRACE_FUNCTION ("cm_mo_call()");
1415
1416 strncpy((char *)num_save, (char *)number, MFW_STRING_LEN-1);
1417 num_save[MFW_STRING_LEN-1] = 0;
1418
1419 /* check the type of number (key sequence), current no function */
1420 typ = ss_decode(number, &rest, &para);
1421 TRACE_EVENT_P1("Type: %d", typ);
1422 if (typ == MFW_SS_DIAL)
1423 {
1424 mfwStrncpy((char *)phone, para.dial.number, MFW_NUM_LEN);
1425
1426 }
1427
1428 if (typ == MFW_SS_HOLD)
1429 {
1430 cm_set_cmd_status(para.chld.mode, para.chld.call);
1431
1432 // Feb 27, 2006 REF:DR OMAPS00067884 x0039928
1433 // Fix : sAT_PercentCHLD() is called if the mode > CHLD_MOD_RelDialCall
1434 if(para.chld.mode > CHLD_MOD_RelDialCall)
1435 aci_result = sAT_PercentCHLD(CMD_SRC_LCL, para.chld.mode, para.chld.call);
1436 else
1437 aci_result = sAT_PlusCHLD(CMD_SRC_LCL, para.chld.mode, para.chld.call);
1438
1439 // Apr 26, 2004 REF: CRR 16545 Ajith K P
1440 // If sAT_PlusCHLD() Fails, Send the user entered string as USSD to network using sAT-Dn().
1441 // So if its not failed just return CM_CTRL_STR, otherwise call sAT_Dn().
1442 if ( (aci_result EQ AT_CMPL ) OR (aci_result EQ AT_EXCT ) OR (aci_result EQ AT_BUSY ))
1443 {
1444 return CM_CTRL_STR;
1445 }
1446 }
1447 //MC 11.04.02
1448 if (typ == MFW_SS_ECT)
1449 {
1450 cm_set_cmd_status(para.chld.mode, para.chld.call);
1451 if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_Ect, 0) != AT_EXCT)
1452 {
1453 //Aug 10, 2005 REF: MMI-SPR-30099 x0018858
1454 //commented this return value.
1455 // return CM_ERROR;
1456 }
1457 else
1458 return CM_CTRL_STR;
1459 }
1460 //MC
1461
1462 if (typ == MFW_SS_DIAL_IDX)
1463 {
1464 return cm_mo_idx(&para, type);
1465 }
1466
1467 switch (typ)
1468 {
1469
1470 //NM
1471 case MFW_SS_CLIR: //jgg wrong not CM_OK should be CM_SS, however cm_grp not used after funtion callnumber called
1472
1473 case MFW_SS_DIAL:
1474 cm_grp = CM_OK;
1475 break;
1476
1477 case MFW_SS_DTMF:
1478 case MFW_SS_CF:
1479 case MFW_SS_CB:
1480 case MFW_SS_CLIP:
1481 case MFW_SS_COLR:
1482 case MFW_SS_COLP:
1483 case MFW_SS_WAIT:
1484 case MFW_SS_HOLD:
1485 case MFW_SS_CCBS:
1486 case MFW_SS_REG_PW:
1487 //Aug 10, 2005 REF: MMI-SPR-30099 x0018858
1488 //Added this case statement.
1489 case MFW_SS_ECT:
1490 cm_grp = CM_SS;
1491 break;
1492
1493 case MFW_SS_USSD:
1494 cm_grp = CM_USSD;
1495 break;
1496
1497 case MFW_SS_SIM_LOCK:
1498 case MFW_SS_SIM_REG_PW:
1499 case MFW_SS_SIM_UNBLCK_PIN:
1500 cm_grp = CM_SIM;
1501 break;
1502
1503 case MFW_SS_MMI:
1504 cm_grp = CM_MMI;
1505 break;
1506
1507 /* SPR#1352 - SH - TTY
1508 * If an SS string has been entered, temporarily enable or disable
1509 * TTY for this call only. */
1510
1511 case MFW_SS_TTY_NEXTCALL_ON:
1512 case MFW_SS_TTY_NEXTCALL_OFF:
1513 {
1514 if (typ==MFW_SS_TTY_NEXTCALL_ON)
1515 {
1516 cm_tty_enable(TRUE);
1517 }
1518 else
1519 {
1520 cm_tty_enable(FALSE);
1521 }
1522
1523 strcpy((char *)num_save, (char *)&num_save[4]); /* Ignore SS string when dialling */
1524 rest = (char *)&number[4]; /* Look at number following SS string */
1525 }
1526 break;
1527 /* SH end */
1528
1529 default:
1530 return CM_ERROR;
1531 }
1532
1533 string = rest;
1534 clir_status = 0;
1535 colr_status = 0;
1536 buf[0] = '\0';
1537 cc_stat.prefix[0] = '\0';
1538 while(strlen(string))
1539 {
1540 TRACE_EVENT("In the while");
1541 new_typ = ss_decode((UBYTE *)string, &rest, &para);
1542 // /*
1543 if (new_typ == MFW_SS_CLIR)
1544 {
1545 clir_status = 1;
1546 if (para.Clir.mode == CLIR_MOD_Supp)
1547 {
1548 strcat((char *)cc_stat.prefix, "*31#");
1549 TRACE_EVENT ("CLIR_MOD_Supp");
1550 }
1551 if (para.Clir.mode == CLIR_MOD_Invoc)
1552 {
1553 strcat((char *)cc_stat.prefix, "#31#");
1554 TRACE_EVENT ("CLIR_MOD_Invoc");
1555 }
1556 }
1557 if (new_typ == MFW_SS_COLR)
1558 colr_status = 1;
1559 if (new_typ == MFW_SS_DIAL)
1560 {
1561 TRACE_EVENT("It's a dial");
1562 /* SPR#1352 - SH - only copy string to dial, not whole string */
1563 if (typ==MFW_SS_TTY_NEXTCALL_ON || typ==MFW_SS_TTY_NEXTCALL_OFF)
1564 {
1565 typ = new_typ;
1566 TRACE_EVENT_P1("phone now holds: %s", phone);
1567 }
1568 else
1569 /* end SH */
1570 {
1571 typ = new_typ;
1572 mfwStrncpy((char *)phone, para.dial.number, MFW_NUM_LEN);
1573 }
1574 }
1575 string = rest;
1576 }
1577
1578 if (!colr_status AND (typ == MFW_SS_DIAL))
1579 {
1580 prefix = cli_prefix & 0xc0;
1581 if (prefix == 0x80)
1582 {
1583 strcat(buf, "*77#");
1584 strcat((char *)cc_stat.prefix, "*77#");
1585 }
1586 if (prefix == 0xc0)
1587 {
1588 strcat(buf, "#77#");
1589 strcat((char *)cc_stat.prefix, "#77#");
1590 }
1591 }
1592
1593 if (typ == MFW_SS_DIAL)
1594 {
1595 res = (T_ACI_RETURN)cm_check_mo_number(phone);
1596 if ( res != CM_OK)
1597 return res;
1598
1599 /* set the outgoing call status */
1600 call_stat = OUTGOING_CALL;
1601 redial_count = 0;
1602 cc_stat.type = OUTGOING_CALL;
1603 cm_grp = CM_OK;
1604 currConnecting = 1;
1605 cm_set_call_mode(type);
1606 }
1607
1608 strcat(buf, (char *)num_save);
1609 if (cm_search_callId(CAL_STAT_Active, &id) EQ CM_OK)
1610 {
1611 /*
1612 * at least one active, this must be put on hold
1613 * by ACI first, then dial
1614 */
1615 cm_set_cmd_status(CHLD_MOD_HldActDial, "");
1616 cc_id = id;
1617 }
1618 if (type == DATA_CALL)
1619 para.dial.callType = D_TOC_Data;
1620
1621 // Apr 22, 2004 REF: CRR MMI-SPR-16873 Rashmi C N(Sasken)
1622 // Using the CLIR status maintained in the flash, while making a call
1623 if (!FFS_flashData.CLIR)
1624 {
1625 res = sAT_Dn(CMD_SRC_LCL, buf, D_CLIR_OVRD_Supp, -1, para.dial.callType);
1626 }
1627 else
1628 {
1629 res = sAT_Dn(CMD_SRC_LCL, buf, D_CLIR_OVRD_Invoc, -1, para.dial.callType);
1630 }
1631
1632 if ((res == AT_FAIL) OR (res == AT_BUSY))
1633 {
1634 if (typ == MFW_SS_CLIP)
1635 return CM_CLI;
1636
1637 call_stat = MFW_CALL_FREE;
1638 return cm_error_code(AT_CMD_D);
1639 }
1640 if (res == AT_CMPL)
1641 {
1642 switch (typ)
1643 {
1644 case MFW_SS_CLIR:
1645 case MFW_SS_CLIP:
1646 case MFW_SS_COLR:
1647 case MFW_SS_COLP:
1648 return CM_CLI;
1649 default:
1650 break;
1651 }
1652 }
1653 return cm_grp;
1654 }
1655
1656
1657 /*
1658 +--------------------------------------------------------------------+
1659 | PROJECT: GSM-MFW (8417) MODULE: MFW_CB |
1660 | STATE : code ROUTINE: rAT_PlusCRING_OFF |
1661 +--------------------------------------------------------------------+
1662
1663
1664 PURPOSE : Alert Off indication from ACI
1665
1666 */
1667
1668 #ifdef FF_2TO1_PS
1669 GLOBAL void rAT_PlusCRING_OFF ( SHORT cId )
1670 {
1671 T_MFW_CM_CALL_STAT stat;
1672 UBYTE ton;
1673 T_CAUSE_ps_cause report; /* Marcus: Extended error reporting: 12/11/2002 */
1674 UBYTE mode;
1675
1676 TRACE_FUNCTION ("rAT_PlusCRING_OFF()");
1677
1678 if (cm_search_callStat(cId, &stat, &ton, &mode) == CM_OK)
1679 {
1680 call_stat = MFW_CALL_FREE;
1681 call_type = MFW_CALL_FREE;
1682
1683 if (stat == CALL_DEACTIVE)
1684 {
1685 dis_connect.call_number = cId;
1686
1687 qAT_PlusCEER( CMD_SRC_LCL, &report);
1688 /* Marcus: Extended error reporting: 12/11/2002: Start */
1689
1690 // TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report);
1691 if (report.ctrl_value != CAUSE_is_from_nwcc)
1692 {
1693 /* Treat Condat defined cause values as if no cause given */
1694 dis_connect.cause = NOT_PRESENT_8BIT;
1695 }
1696 else
1697 {
1698 /* Standards defined cause value is given */
1699 dis_connect.cause = report.value.nwcc_cause;
1700 }
1701 TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
1702 /* Marcus: Extended error reporting: 12/11/2002: End */
1703 cm_signal(E_CM_DISCONNECT, &dis_connect);
1704 return;
1705 }
1706 cm_signal(E_CM_RING_OFF, 0);
1707 }
1708 }
1709 #else
1710 GLOBAL void rAT_PlusCRING_OFF ( SHORT cId )
1711 {
1712 T_MFW_CM_CALL_STAT stat;
1713 UBYTE ton;
1714 USHORT report; /* Marcus: Extended error reporting: 12/11/2002 */
1715 UBYTE mode;
1716
1717 TRACE_FUNCTION ("rAT_PlusCRING_OFF()");
1718
1719 if (cm_search_callStat(cId, &stat, &ton, &mode) == CM_OK)
1720 {
1721 call_stat = MFW_CALL_FREE;
1722 call_type = MFW_CALL_FREE;
1723
1724 if (stat == CALL_DEACTIVE)
1725 {
1726 dis_connect.call_number = cId;
1727
1728 qAT_PlusCEER( CMD_SRC_LCL, &report);
1729 /* Marcus: Extended error reporting: 12/11/2002: Start */
1730 TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report);
1731 if (GET_CAUSE_DEFBY(report) == DEFBY_CONDAT)
1732 {
1733 /* Treat Condat defined cause values as if no cause given */
1734 dis_connect.cause = NOT_PRESENT_8BIT;
1735 }
1736 else
1737 {
1738 /* Standards defined cause value is given */
1739 dis_connect.cause = GET_CAUSE_VALUE(report);
1740 }
1741 TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
1742 /* Marcus: Extended error reporting: 12/11/2002: End */
1743 cm_signal(E_CM_DISCONNECT, &dis_connect);
1744 return;
1745 }
1746 cm_signal(E_CM_RING_OFF, 0);
1747 }
1748 }
1749 #endif
1750
1751 /*
1752 +--------------------------------------------------------------------+
1753 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
1754 | STATE : code ROUTINE : rAT_PlusCRING |
1755 +--------------------------------------------------------------------+
1756
1757
1758 PURPOSE : Alert indication from ACI
1759
1760 */
1761
1762 void rAT_PlusCRING(T_ACI_CRING_MOD mode,
1763 T_ACI_CRING_TYP type1,
1764 T_ACI_CRING_TYP type2)
1765 {
1766 SHORT call_number;
1767
1768 TRACE_FUNCTION ("rAT_PlusCRING()");
1769
1770 in_call.result = Present;
1771
1772 /* search the call identifier */
1773 if (cm_search_callId(CAL_STAT_Wait, &call_number) == CM_OK)
1774 in_call.call_number = call_number;
1775 else
1776 in_call.call_number = 0;
1777
1778 /* If redial is active, it must be stoped. */
1779 if (call_stat == REDIALING_CALL)
1780 {
1781 cm_stop_redialTim();
1782 rdl.redial_mode = CM_REDIAL_INCOMING;
1783 cm_signal(E_CM_REDIAL, &rdl);
1784 }
1785
1786 if (mode EQ CRING_MOD_Direct)
1787 {
1788 switch (type1)
1789 {
1790 /* Voice call */
1791 case CRING_TYP_Voice:
1792 if (type2 EQ CRING_TYP_NotPresent)
1793 {
1794 in_call.type = VOICE_CALL;
1795 cm_set_call_mode(VOICE_CALL);
1796 }
1797 else
1798 {
1799 switch (type2)
1800 {
1801 case CRING_TYP_Sync:
1802 case CRING_TYP_Async:
1803 case CRING_TYP_RelSync:
1804 case CRING_TYP_RelAsync:
1805 in_call.type = VFD_VOICE;
1806 cm_bc_parameter(type2);
1807 cm_set_call_mode(VFD_VOICE);
1808 break;
1809 /*MC, SPR 1026, check for line1 and line2*/
1810 case CRING_TYP_Voice:
1811 in_call.type = VOICE_CALL;
1812 cm_set_call_mode(VOICE_CALL);
1813 break;
1814 case CRING_TYP_AuxVoice:
1815 cm_set_call_mode(AuxVOICE_CALL);
1816 in_call.type = AuxVOICE_CALL;
1817 break;
1818 /*MC, end*/
1819 default:
1820 in_call.type = VOICE_CALL;
1821 cm_set_call_mode(VOICE_CALL);
1822 break;
1823 }
1824 }
1825 break;
1826 /*MC, SPR 1026, Added case of Type1=CRING_TYP_AuxVoice*/
1827 /*assuming line 2 is handled like line 1*/
1828 case CRING_TYP_AuxVoice:
1829 if (type2 EQ CRING_TYP_NotPresent)
1830 {
1831 in_call.type = AuxVOICE_CALL;
1832 cm_set_call_mode(AuxVOICE_CALL);
1833 }
1834 else
1835 {
1836 switch (type2)
1837 {
1838 case CRING_TYP_Sync:
1839 case CRING_TYP_Async:
1840 case CRING_TYP_RelSync:
1841 case CRING_TYP_RelAsync:
1842 in_call.type = VFD_VOICE;
1843 cm_bc_parameter(type2);
1844 cm_set_call_mode(VFD_VOICE);
1845 break;
1846 case CRING_TYP_Voice:
1847 in_call.type = VOICE_CALL;
1848 cm_set_call_mode(VOICE_CALL);
1849 break;
1850 case CRING_TYP_AuxVoice:
1851 cm_set_call_mode(AuxVOICE_CALL);
1852 in_call.type = AuxVOICE_CALL;
1853 break;
1854 default:
1855 in_call.type = VOICE_CALL;
1856 cm_set_call_mode(VOICE_CALL);
1857 break;
1858 }
1859 }
1860 break;
1861 /*MC, end*/
1862 /* Data call */
1863 case CRING_TYP_Sync:
1864 case CRING_TYP_Async:
1865 case CRING_TYP_RelSync:
1866 case CRING_TYP_RelAsync:
1867 in_call.type = DATA_CALL;
1868 cm_bc_parameter(type1);
1869 cm_set_call_mode(DATA_CALL);
1870 break;
1871
1872 case CRING_TYP_Fax:
1873 in_call.type = FAX_CALL;
1874 in_call.bc1.conn_elem = Transparent;
1875 cm_set_call_mode(FAX_CALL);
1876 break;
1877
1878 default:
1879 in_call.result = NotPresent;
1880 break;
1881 }
1882 call_stat = INCOMING_CALL;
1883 }
1884
1885 if (mode EQ CRING_MOD_Alternate)
1886 {
1887 cm_build_callType(type1, type2);
1888 cm_bc_parameter(type1);
1889 cm_bc_parameter(type2);
1890 cm_set_call_mode(in_call.type);
1891 }
1892 }
1893
1894
1895 /*
1896 +--------------------------------------------------------------------+
1897 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
1898 | STATE : code ROUTINE: rAT_PlusCLIP |
1899 +--------------------------------------------------------------------+
1900
1901
1902 PURPOSE : The calling line identification for an incomming call.
1903
1904 */
1905
1906 #ifdef NO_ASCIIZ
1907 void rAT_PlusCLIP(T_ACI_CLIP_STAT stat,
1908 CHAR * number,
1909 T_ACI_TOA * type,
1910 U8 validity,
1911 CHAR * subaddr,
1912 T_ACI_TOS * satype,
1913 T_ACI_PB_TEXT * alpha)
1914 {
1915 int flag;
1916
1917 TRACE_FUNCTION ("rAT_PlusCLIP()");
1918
1919 flag = 0;
1920
1921 if (number != NULL)
1922 {
1923 mfwStrncpy((char *)in_call.number, (char *)number, MFW_NUM_LEN);
1924 in_call.ton = phb_cvtTon(type->ton);
1925 flag = 1;
1926 }
1927 else
1928 memset(in_call.number, '\0', MFW_NUM_LEN);
1929
1930 if (alpha != NULL)
1931 {
1932 in_call.name.len = alpha->len;
1933 if (alpha->len)
1934 {
1935 memcpy(in_call.name.data,
1936 alpha->data,
1937 alpha->len);
1938 flag = 1;
1939 }
1940 }
1941 else
1942 in_call.name.len = 0;
1943
1944
1945 if (subaddr != NULL)
1946 {
1947 mfwStrncpy((char *)in_call.subaddr, (char *)subaddr, MFW_SUBADR_LEN);
1948 flag = 1;
1949 }
1950 else
1951 memset(in_call.subaddr, '\0', MFW_SUBADR_LEN);
1952
1953 if (flag == 1)
1954 in_call.result = Present;
1955 else
1956 in_call.result = 0;
1957
1958 cm_signal(E_CM_CW, &in_call);
1959 }
1960
1961 #else
1962
1963 void rAT_PlusCLIP(T_ACI_CLIP_STAT stat,
1964 CHAR * number,
1965 T_ACI_TOA * type,
1966 U8 validity,
1967 CHAR * subaddr,
1968 T_ACI_TOS * satype,
1969 CHAR * alpha)
1970 {
1971 int flag;
1972
1973 TRACE_FUNCTION ("rAT_PlusCLIP()");
1974
1975 flag = 0;
1976 // in_call.result = 0;
1977
1978 if (number != NULL)
1979 {
1980 mfwStrncpy((char *)in_call.number, (char *)number, MFW_NUM_LEN);
1981 in_call.ton = phb_cvtTon(type->ton);
1982 flag = 1;
1983 }
1984 else
1985 memset(in_call.number, '\0', MFW_NUM_LEN);
1986
1987 if (alpha != NULL)
1988 {
1989 mfwStrncpy((char *)in_call.name, (char *)alpha, MFW_TAG_LEN);
1990 flag = 1;
1991 }
1992 else
1993 memset(in_call.name, '\0', MFW_TAG_LEN);
1994
1995 if (subaddr != NULL)
1996 {
1997 mfwStrncpy((char *)in_call.subaddr, (char *)subaddr, MFW_SUBADR_LEN);
1998 flag = 1;
1999 }
2000 else
2001 memset(in_call.subaddr, '\0', MFW_SUBADR_LEN);
2002
2003 if (flag == 1)
2004 in_call.result = Present;
2005 else
2006 in_call.result = 0;
2007
2008 cm_signal(E_CM_CW, &in_call);
2009 }
2010 #endif
2011
2012 /*
2013 +--------------------------------------------------------------------+
2014 | PROJECT : GSM-MFW (8417) MODULE : MFW_CM |
2015 | STATE : code ROUTINE : rAT_PlusCOLP |
2016 +--------------------------------------------------------------------+
2017
2018
2019 PURPOSE : Connected line presentation indication from ACI
2020
2021 */
2022
2023 #ifdef NO_ASCIIZ
2024 GLOBAL void rAT_PlusCOLP ( T_ACI_COLP_STAT stat,
2025 CHAR* number,
2026 T_ACI_TOA* type,
2027 CHAR* subaddr,
2028 T_ACI_TOS* satype,
2029 T_ACI_PB_TEXT* alpha)
2030 {
2031
2032 TRACE_FUNCTION ("rAT_PlusCOLP()");
2033
2034 if (number != NULL)
2035 {
2036 mfwStrncpy((char *)out_call.number, (char *)number, MFW_NUM_LEN);
2037 out_call.ton = phb_cvtTon(type->ton);
2038 }
2039 else
2040 memset(out_call.number, '\0', MFW_NUM_LEN);
2041
2042 /*NM, p001 */
2043 if(alpha != NULL)
2044 /*NM, p001 end */
2045 {
2046 out_call.name.len = MINIMUM(alpha->len, MFW_TAG_LEN);
2047 if (alpha->len)
2048 memcpy(out_call.name.data,
2049 alpha->data,
2050 alpha->len);
2051 }
2052
2053 if (subaddr != NULL)
2054 mfwStrncpy((char *)out_call.subaddr, (char *)subaddr, MFW_SUBADR_LEN);
2055 else
2056 memset(out_call.subaddr, '\0', MFW_SUBADR_LEN);
2057
2058 if (number != NULL)
2059 cm_signal(E_CM_COLP, &out_call);
2060 }
2061
2062 #else
2063
2064 GLOBAL void rAT_PlusCOLP ( T_ACI_COLP_STAT stat,
2065 CHAR* number,
2066 T_ACI_TOA* type,
2067 CHAR* subaddr,
2068 T_ACI_TOS* satype,
2069 CHAR* alpha)
2070 {
2071 TRACE_FUNCTION ("rAT_PlusCOLP()");
2072
2073 // patch PMA 15 06 99 from Andreas
2074 // if (stat == -1)
2075 // return;
2076
2077 if (number != NULL)
2078 {
2079 mfwStrncpy((char *)out_call.number, (char *)number, MFW_NUM_LEN);
2080 out_call.ton = phb_cvtTon(type->ton);
2081 }
2082 else
2083 memset(out_call.number, '\0', MFW_NUM_LEN);
2084
2085 if (alpha != NULL)
2086 mfwStrncpy((char *)out_call.name, (char *)alpha, MFW_TAG_LEN);
2087 else
2088 memset(out_call.name, '\0', MFW_TAG_LEN);
2089
2090 if (subaddr != NULL)
2091 mfwStrncpy((char *)out_call.subaddr, (char *)subaddr, MFW_SUBADR_LEN);
2092 else
2093 memset(out_call.subaddr, '\0', MFW_SUBADR_LEN);
2094
2095 // patch PMA 15 06 99 from Andreas
2096 if (number != NULL)
2097 cm_signal(E_CM_COLP, &out_call);
2098 }
2099 #endif
2100
2101 /*
2102 +--------------------------------------------------------------------+
2103 | PROJECT : GSM-MFW (8417) MODULE : MFW_CM |
2104 | STATE : code ROUTINE : rAT_PlusCCWA |
2105 +--------------------------------------------------------------------+
2106
2107
2108 PURPOSE : Connected line presentation indication from ACI
2109
2110 */
2111
2112 #ifdef NO_ASCIIZ
2113
2114 GLOBAL void rAT_PlusCCWA ( T_ACI_CLSSTAT * clsStatLst,
2115 CHAR * number,
2116 T_ACI_TOA * type,
2117 U8 validity,
2118 T_ACI_CLASS call_class,
2119 T_ACI_PB_TEXT * alpha)
2120 {
2121 SHORT call_number;
2122
2123 TRACE_FUNCTION("rAT_PlusCCWA()");
2124
2125 in_call.result = NotPresent;
2126 if (clsStatLst == 0)
2127 {
2128 if (number != NULL)
2129 {
2130 mfwStrncpy((char *)in_call.number, (char *)number, MFW_NUM_LEN);
2131 in_call.ton = phb_cvtTon(type->ton);
2132 }
2133 else
2134 memset(in_call.number, '\0', MFW_NUM_LEN);
2135
2136 if (alpha != NULL)
2137 in_call.name.len = alpha->len;
2138 else
2139 in_call.name.len = 0;
2140
2141 if (in_call.name.len)
2142 {
2143 memcpy(in_call.name.data,
2144 alpha->data,
2145 alpha->len);
2146 }
2147
2148 in_call.type = cm_callTyp_cvt(call_class);
2149
2150 if (number != 0 || in_call.name.len != 0 || in_call.type != NONE_TYPE)
2151 in_call.result = Present;
2152
2153 cm_search_callId(CAL_STAT_Wait, &call_number);
2154 in_call.call_number = call_number;
2155
2156 cm_signal(E_CM_CW, &in_call);
2157 }
2158 }
2159
2160 #else
2161
2162 GLOBAL void rAT_PlusCCWA ( T_ACI_CLSSTAT * clsStatLst,
2163 CHAR * number,
2164 T_ACI_TOA * type,
2165 U8 validity,
2166 T_ACI_CLASS call_class,
2167 CHAR * alpha)
2168 {
2169 SHORT call_number;
2170
2171 in_call.result = NotPresent;
2172 if (clsStatLst == 0)
2173 {
2174 if (number != NULL)
2175 {
2176 mfwStrncpy((char *)in_call.number, (char *)number, MFW_NUM_LEN);
2177 in_call.ton = phb_cvtTon(type->ton);
2178 }
2179 else
2180 memset(in_call.number, '\0', MFW_NUM_LEN);
2181
2182 if (alpha != NULL)
2183 mfwStrncpy((char *)in_call.name, (char *)alpha, MFW_TAG_LEN);
2184 else
2185 memset(in_call.name, '\0', MFW_TAG_LEN);
2186
2187 in_call.type = cm_callTyp_cvt(call_class);
2188
2189 if (number != 0 || alpha != 0 || in_call.type != NONE_TYPE)
2190 in_call.result = Present;
2191
2192 cm_search_callId(CAL_STAT_Wait, &call_number);
2193 in_call.call_number = call_number;
2194
2195 cm_signal(E_CM_CW, &in_call);
2196 }
2197 }
2198 #endif
2199
2200 /*
2201 +--------------------------------------------------------------------+
2202 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
2203 | STATE : code ROUTINE : cm_mt_reject |
2204 +--------------------------------------------------------------------+
2205
2206
2207 PURPOSE : Reject the incoming call.
2208
2209 */
2210
2211 void cm_mt_reject()
2212 {
2213 TRACE_FUNCTION ("cm_mt_reject()");
2214
2215 if (currAccepting)
2216 {
2217 currAccepting = 0; /* ES!! 210999 */
2218 sAT_Abort(CMD_SRC_LCL, AT_CMD_A);
2219 return;
2220 }
2221
2222 cmd_hold = MFW_CM_MT_REJECT;
2223 cm_search_callId(CAL_STAT_Wait, &dis_connect.call_number);
2224 sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelHldOrUdub, 0);
2225 }
2226
2227
2228 /*
2229 +--------------------------------------------------------------------+
2230 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
2231 | STATE : code ROUTINE: cm_mt_accept |
2232 +--------------------------------------------------------------------+
2233
2234
2235 PURPOSE : Accept the incoming call. If the active call exists,
2236 place this active call on hold and accepts the
2237 waiting call.
2238
2239 */
2240
2241 void cm_mt_accept()
2242 {
2243 SHORT call_number;
2244 T_MFW_CM_CALL_STAT stat; /* SPR#1983 - SH */
2245 UBYTE ton;
2246 UBYTE mode;
2247
2248 TRACE_FUNCTION ("cm_mt_accept()");
2249
2250 if (cm_search_callId(CAL_STAT_Active, &call_number) != CM_OK)
2251 {
2252 if (sAT_A(CMD_SRC_LCL) NEQ AT_EXCT)
2253 {
2254 TRACE_ERROR("sAT_A error");
2255 }
2256 else
2257 {
2258 currAccepting = 1; /* ES!! 210999 */
2259 }
2260 }
2261 else
2262 {
2263 cmd_hold = MFW_CM_MT_ACCEPT;
2264
2265 /* SPR#1983 - SH - Get status of active call */
2266
2267 cm_search_callStat(call_number, &stat, &ton, &mode);
2268
2269 if (cm_search_callId(CAL_STAT_Wait, &call_number) EQ CM_OK)
2270 cc_id = call_number;
2271
2272 /* SPR#1983 - SH - If data call is active, end it and accept other call */
2273
2274 if (mode==DATA_CALL)
2275 {
2276 /*
2277 * Accepting a call when there is an active data call,
2278 * so drop the active call and accept the waiting call by the
2279 * equivalent of the AT+CHLD=1 command.
2280 */
2281 cm_set_cmd_status(CHLD_MOD_RelActAndAcpt, "");
2282 if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActAndAcpt, 0) NEQ AT_EXCT)
2283 {
2284 TRACE_ERROR("sAT_PlusCHLD(CHLD_MOD_RelActAndAcpt) error");
2285 }
2286 }
2287
2288 else /* SPR#1983 - SH - Important! Acts on next 'if' */
2289
2290 /* Marcus: issue 1049: 03/09/2002: Start */
2291 if (cm_search_callId(CAL_STAT_Held, &call_number) EQ CM_OK)
2292 {
2293 /*
2294 * Accepting a call when there is already an active call and a held
2295 * call, so drop the active call and accept the waiting call by the
2296 * equivalent of the AT+CHLD=1 command.
2297 */
2298 cm_set_cmd_status(CHLD_MOD_RelActAndAcpt, "");
2299 if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActAndAcpt, 0) NEQ AT_EXCT)
2300 {
2301 TRACE_ERROR("sAT_PlusCHLD(CHLD_MOD_RelActAndAcpt) error");
2302 }
2303 }
2304 else
2305 {
2306 /*
2307 * Accepting a call when there is already an active call but no held
2308 * call, so hold the active call and accept the waiting call by the
2309 * equivalent of the AT+CHLD=2 command.
2310 */
2311 cm_set_cmd_status(CHLD_MOD_HldActAndAcpt, "");
2312 if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_HldActAndAcpt, 0) NEQ AT_EXCT)
2313 {
2314 TRACE_ERROR("sAT_PlusCHLD(CHLD_MOD_HldActAndAcpt) error");
2315 }
2316 }
2317 /* Marcus: issue 1049: 03/09/2002: End */
2318 }
2319 }
2320
2321
2322 /*
2323 +--------------------------------------------------------------------+
2324 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
2325 | STATE : code ROUTINE : cm_end_all |
2326 +--------------------------------------------------------------------+
2327
2328
2329 PURPOSE : End all calls (Held and Active)
2330
2331 */
2332
2333 void cm_end_all(void)
2334 {
2335 T_ACI_RETURN aci_res; // The value returned by sAT_H
2336
2337 TRACE_EVENT("cm_end_all()");
2338
2339 aci_res = sAT_H(CMD_SRC_LCL);
2340
2341 if (aci_res == AT_EXCT)
2342 {
2343 TRACE_EVENT("sAT_H returned AT_EXCT");
2344 cmd_hold = MFW_CM_DISCONNECT_ALL;
2345 }
2346 else
2347 {
2348 TRACE_EVENT_P1("sAT_H returned %d", aci_res);
2349 }
2350 return;
2351 }
2352
2353
2354 /*
2355 +--------------------------------------------------------------------+
2356 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
2357 | STATE : code ROUTINE : cm_ok_connect |
2358 +--------------------------------------------------------------------+
2359
2360
2361 PURPOSE : The connect is successful.
2362
2363 */
2364
2365 void cm_ok_connect(void)
2366 {
2367 SHORT call_number;
2368
2369 TRACE_FUNCTION ("cm_ok_connect()");
2370
2371 currAccepting = 0; /* ES!! 210999 */
2372 currConnecting = 0; /* ES!! 290999 */
2373
2374 if (cc_stat.type == REDIALING_CALL)
2375 {
2376 rdl.redial_mode = CM_REDIAL_SUCCESS;
2377 cm_signal(E_CM_REDIAL, &rdl);
2378 }
2379
2380 cm_search_callId(CAL_STAT_Active, &call_number);
2381
2382 /* allow a new outgoing */
2383 call_stat = MFW_CALL_FREE;
2384 call_type = MFW_CALL_FREE;
2385 cmd_hold = MFW_CM_NO_FLAG;
2386
2387 cm_signal(E_CM_CONNECT_ACK, &call_number);
2388 }
2389
2390
2391 /*
2392 +--------------------------------------------------------------------+
2393 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
2394 | STATE : code ROUTINE : cm_rmt_ok_connect |
2395 +--------------------------------------------------------------------+
2396
2397
2398 PURPOSE : The connect is successful.
2399
2400 */
2401
2402 void cm_rmt_ok_connect()
2403 {
2404 SHORT call_number;
2405
2406 TRACE_FUNCTION ("cm_rmt_ok_connect()");
2407
2408 cm_search_callId(CAL_STAT_Active, &call_number);
2409
2410 cm_signal(E_CM_CONNECT_ACK, &call_number);
2411 }
2412
2413
2414 /*
2415 +--------------------------------------------------------------------+
2416 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
2417 | STATE : code ROUTINE : cm_error_connect |
2418 +--------------------------------------------------------------------+
2419
2420
2421 PURPOSE : The connection is not successful
2422
2423 */
2424
2425 #ifdef FF_2TO1_PS
2426 void cm_error_connect(SHORT call_number)
2427 {
2428 int i;
2429 T_CAUSE_ps_cause report; /* Marcus: Extended error reporting: 12/11/2002 */
2430 USHORT extend_report; /* API - 1564 - 16-01-03 - add this variable to store the new error code */
2431
2432 TRACE_FUNCTION ("cm_error_connect()");
2433
2434 currAccepting = 0; /* ES!! 210999 */
2435 currConnecting = 0; /* ES!! 290999 */
2436
2437 /* send event */
2438 dis_connect.call_number = call_number;
2439
2440 qAT_PlusCEER( CMD_SRC_LCL, &report);
2441 /* Marcus: Extended error reporting: 12/11/2002: Start */
2442 // TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report);
2443
2444 /* API - 1564 - 16-01-03 - store the error value to the new variable & throughout this function replace 'report' with 'extend_report */
2445 extend_report = report.value.nwcc_cause;
2446
2447 if (report.ctrl_value != CAUSE_is_from_nwcc)
2448 {
2449 /* Treat Condat defined cause values as if no cause given */
2450 dis_connect.cause = NOT_PRESENT_8BIT;
2451 }
2452 else
2453 {
2454 /* Standards defined cause value is given */
2455 dis_connect.cause = report.value.nwcc_cause;
2456 }
2457 TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
2458 /* Marcus: Extended error reporting: 12/11/2002: End */
2459 cm_signal(E_CM_DISCONNECT, &dis_connect);
2460 TRACE_EVENT("passed the E_CM_DISCONNECT point");
2461
2462 if ((call_stat EQ OUTGOING_CALL)
2463 AND (call_type NEQ MFW_ECC_CALL)
2464 AND ((redial_stat EQ CM_REDIAL_AUTO) OR (redial_stat EQ CM_REDIAL_MANU)))
2465 {
2466 /* If this call is 2nd outgoing call, redial is not started */
2467 if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) EQ AT_CMPL)
2468 {
2469 for (i=0; i<MAX_CALL_NR; i++)
2470 {
2471 if (call_tab[i].index == -1)
2472 break;
2473
2474 if ((call_tab[i].status == CAL_STAT_NotPresent)
2475 OR (call_tab[i].status == CAL_STAT_DeactiveReq))
2476 continue;
2477
2478 if (call_tab[i].calType == CAL_TYPE_MOC)
2479 {
2480 call_stat = MFW_CALL_FREE;
2481 call_type = MFW_CALL_FREE;
2482 cmd_hold = MFW_CM_NO_FLAG;
2483 return;
2484 }
2485 }
2486 }
2487
2488 /* check blacklist whether it is full */
2489 if (black_list.count == MAX_BLACKLIST_NUM)
2490 {
2491 TRACE_EVENT ("blacklist is now full");
2492
2493 /* Blacklist is now full and
2494 MT shall prohibit further automatic call attempts
2495 */
2496 redial_stat = CM_REDIAL_OFF;
2497
2498
2499 /* allow a new outgoing */
2500 call_stat = MFW_CALL_FREE;
2501 call_type = MFW_CALL_FREE;
2502 cc_stat.type = MFW_CALL_FREE;
2503
2504 rdl.redial_mode = CM_REDIAL_BLACKLIST;
2505 cm_signal(E_CM_REDIAL, &rdl);
2506 return;
2507 }
2508
2509 /* check the registration staus */
2510 if (nm_reg_status() == MFW_NO_SERVICE)
2511 {
2512 call_stat = MFW_CALL_FREE;
2513 call_type = MFW_CALL_FREE;
2514 cc_stat.type = MFW_CALL_FREE;
2515
2516 rdl.redial_mode = CM_REDIAL_NO_SERVICE;
2517 cm_signal(E_CM_REDIAL, &rdl);
2518 return;
2519 }
2520
2521 TRACE_EVENT_P1("report = %d", extend_report);
2522 switch (extend_report)
2523 {
2524 case 28:
2525 // API - 1480 - Added this code to stop redial on an incorrect number
2526 if(!redial_count)
2527 {
2528 call_stat = MFW_CALL_FREE;
2529 call_type = MFW_CALL_FREE;
2530 cc_stat.type = MFW_CALL_FREE;
2531
2532 rdl.redial_mode = CM_REDIAL_ABORTED;
2533 cm_signal(E_CM_REDIAL, &rdl);
2534 return;
2535 }
2536 case 1: /* check whether the reason is in category 3 (GSM 02.07) */
2537 case 3:
2538 case 22:
2539 case 38:
2540 TRACE_EVENT ("category 3");
2541 if (!redial_count)
2542 {
2543 /* redial_count == 0;
2544 this is for the first outgoing call and
2545 now it is going to start the Auto-redial procedure
2546 */
2547 cc_stat.type = REDIALING_CALL;
2548 cc_stat.call_number = 0;
2549
2550 call_stat = REDIALING_CALL;
2551 rdl.redial_mode = CM_REDIAL_STARTED;
2552 mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
2553
2554 #ifdef NO_ASCIIZ
2555 rdl.name.len = cc_stat.name.len;
2556 memcpy(rdl.name.data,
2557 cc_stat.name.data,
2558 cc_stat.name.len);
2559 #else
2560 mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
2561 // strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
2562 #endif
2563 rdl.ton = cc_stat.ton;
2564 rdl.type = cc_stat.mode;
2565
2566 /* reasons in the category 3 have
2567 a call repeat attempts of max. 1 !
2568 */
2569 redial_count = MAX_REDIAL_ATTEMPT-1;
2570 cm_signal(E_CM_REDIAL, &rdl);
2571 return;
2572 }
2573 else
2574 redial_count = MAX_REDIAL_ATTEMPT;
2575 break;
2576
2577 case 17: /* check whether the reason is in category 1 and 2 (GSM 02.07) */
2578 case 18:
2579 case 19:
2580 case 27:
2581 case 34:
2582 case 41:
2583 case 42:
2584 case 44:
2585 case 47:
2586 TRACE_EVENT ("category 1 & 2");
2587 if (!redial_count)
2588 {
2589 /* redial_count == 0
2590 this is for the first outgoing call and
2591 now it is going to start the Auto-redial procedure
2592 */
2593 cc_stat.type = REDIALING_CALL;
2594 cc_stat.call_number = 0;
2595
2596 call_stat = REDIALING_CALL;
2597 rdl.redial_mode = CM_REDIAL_STARTED;
2598 mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
2599 #ifdef NO_ASCIIZ
2600 rdl.name.len = cc_stat.name.len;
2601 memcpy(rdl.name.data,
2602 cc_stat.name.data,
2603 cc_stat.name.len);
2604 #else
2605 mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
2606 // strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
2607 #endif
2608 rdl.ton = cc_stat.ton;
2609 rdl.type = cc_stat.mode;
2610
2611 /* reasons in the category 1 and 2 have
2612 a call repeat attempts of max. 10 !
2613 */
2614
2615 cm_signal(E_CM_REDIAL, &rdl);
2616 return;
2617 }
2618
2619 if (redial_count >= 1 AND redial_count <= 3)
2620 {
2621 timStart(redialTim24);
2622 call_stat = REDIALING_CALL;
2623 cc_stat.call_number = 0;
2624 return;
2625 }
2626
2627 if (redial_count >= 4 AND redial_count < MAX_REDIAL_ATTEMPT)
2628 {
2629 timStart(redialTim5);
2630 call_stat = REDIALING_CALL;
2631 cc_stat.call_number = 0;
2632 return;
2633 }
2634 #ifdef CUSTOMER_6366
2635 // JP PATCH The MMI needs to know if the 'error disconnect' has
2636 // resulted in redial starting irrespective of whether this was a redial attempt or not
2637 rdl.redial_mode = CM_REDIAL_STARTED;
2638 cm_signal(E_CM_REDIAL, &rdl);
2639 // END JP PATCH
2640 #endif /* CUSTOMER_6366 */
2641 break;
2642
2643 default:
2644 if (redial_count)
2645 {
2646 rdl.redial_mode = CM_REDIAL_STOP;
2647 mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
2648 #ifdef NO_ASCIIZ
2649 rdl.name.len = cc_stat.name.len;
2650 memcpy(rdl.name.data,
2651 cc_stat.name.data,
2652 cc_stat.name.len);
2653 #else
2654 mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);//???
2655 // strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
2656 #endif
2657 rdl.ton = cc_stat.ton;
2658 rdl.type = cc_stat.mode;
2659 cm_signal(E_CM_REDIAL, &rdl);
2660 }
2661 /* allow a new outgoing */
2662 call_stat = MFW_CALL_FREE;
2663 call_type = MFW_CALL_FREE;
2664 cc_stat.type = MFW_CALL_FREE;
2665 return;
2666 }
2667
2668 if (redial_count >= MAX_REDIAL_ATTEMPT
2669 AND black_list.count < MAX_BLACKLIST_NUM)
2670 {
2671 mfwStrncpy((char *)black_list.number[black_list.count],
2672 (char *)cc_stat.number, MFW_NUM_LEN);
2673 black_list.count++;
2674
2675 rdl.redial_mode = CM_REDIAL_BLACKLISTED;
2676 mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
2677 #ifdef NO_ASCIIZ
2678 rdl.name.len = cc_stat.name.len;
2679 memcpy(rdl.name.data,
2680 cc_stat.name.data,
2681 cc_stat.name.len);
2682 #else
2683 mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
2684 // strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
2685 #endif
2686 rdl.ton = cc_stat.ton;
2687 rdl.type = cc_stat.mode;
2688 rdl.left_attempts = 0;
2689 cc_stat.call_number = 0;
2690 cm_signal(E_CM_REDIAL, &rdl);
2691 }
2692 }
2693
2694 /* allow a new outgoing */
2695 call_stat = MFW_CALL_FREE;
2696 call_type = MFW_CALL_FREE;
2697 cc_stat.type = MFW_CALL_FREE;
2698 }
2699 #else
2700 void cm_error_connect(SHORT call_number)
2701 {
2702
2703 int i;
2704 USHORT report; /* Marcus: Extended error reporting: 12/11/2002 */
2705 USHORT extend_report; /* API - 1564 - 16-01-03 - add this variable to store the new error code */
2706 // Apr 06 2005 REF: CRR 29989 xpradipg
2707 // local definition
2708 #ifdef FF_MMI_OPTIM
2709 T_ACI_CAL_ENTR *call_tab;//[MAX_CALL_NR];
2710 #endif
2711 // Apr 14, 2005 REF: CRR 29991 xpradipg
2712 // local definition
2713 #ifdef FF_MMI_OPTIM
2714 UBYTE count;
2715 UBYTE blackListNum[MFW_NUM_LEN];
2716 int32 file = 0;
2717 #endif
2718 TRACE_FUNCTION ("cm_error_connect()");
2719
2720 currAccepting = 0; /* ES!! 210999 */
2721 currConnecting = 0; /* ES!! 290999 */
2722
2723 /* send event */
2724 dis_connect.call_number = call_number;
2725
2726 qAT_PlusCEER( CMD_SRC_LCL, &report);
2727 /* Marcus: Extended error reporting: 12/11/2002: Start */
2728 TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report);
2729
2730 /* API - 1564 - 16-01-03 - store the error value to the new variable & throughout this function replace 'report' with 'extend_report */
2731 extend_report = GET_CAUSE_VALUE(report);
2732
2733 if (GET_CAUSE_DEFBY(extend_report) == DEFBY_CONDAT)
2734 {
2735 /* Treat Condat defined cause values as if no cause given */
2736 dis_connect.cause = NOT_PRESENT_8BIT;
2737 }
2738 else
2739 {
2740 /* Standards defined cause value is given */
2741 dis_connect.cause = GET_CAUSE_VALUE(extend_report);
2742 }
2743 TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
2744 /* Marcus: Extended error reporting: 12/11/2002: End */
2745 cm_signal(E_CM_DISCONNECT, &dis_connect);
2746 TRACE_EVENT("passed the E_CM_DISCONNECT point");
2747
2748 if ((call_stat EQ OUTGOING_CALL)
2749 AND (call_type NEQ MFW_ECC_CALL)
2750 AND ((redial_stat EQ CM_REDIAL_AUTO) OR (redial_stat EQ CM_REDIAL_MANU)))
2751 {
2752 // Apr 06 2005 REF: CRR 29989 xpradipg
2753 // allocate memory
2754 #ifdef FF_MMI_OPTIM
2755 call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
2756 if( NULL == call_tab)
2757 return;
2758 #endif
2759 /* If this call is 2nd outgoing call, redial is not started */
2760 if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) EQ AT_CMPL)
2761 {
2762 for (i=0; i<MAX_CALL_NR; i++)
2763 {
2764 if (call_tab[i].index == -1)
2765 break;
2766
2767 if ((call_tab[i].status == CAL_STAT_NotPresent)
2768 OR (call_tab[i].status == CAL_STAT_DeactiveReq))
2769 continue;
2770
2771 if (call_tab[i].calType == CAL_TYPE_MOC)
2772 {
2773 call_stat = MFW_CALL_FREE;
2774 call_type = MFW_CALL_FREE;
2775 cmd_hold = MFW_CM_NO_FLAG;
2776 // Apr 06 2005 REF: CRR 29989 xpradipg
2777 // deallocate memory
2778 #ifdef FF_MMI_OPTIM
2779 if(call_tab)
2780 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
2781 #endif
2782 return;
2783 }
2784 }
2785 }
2786 // Apr 06 2005 REF: CRR 29989 xpradipg
2787 // deallocate memory
2788 #ifdef FF_MMI_OPTIM
2789 if(call_tab)
2790 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
2791 #endif
2792 // Apr 14, 2005 REF: CRR 29991 xpradipg
2793 // read the list into the variable
2794 #ifdef FF_MMI_OPTIM
2795 if((file = flash_MMI_blackList_open()) >= 0 )
2796 {
2797 if(flash_MMI_blackList_read(file,(U8*)&count, 1,0) > 0)
2798 {
2799 if(count == MAX_BLACKLIST_NUM)
2800 #else
2801 /* check blacklist whether it is full */
2802 if (black_list.count == MAX_BLACKLIST_NUM)
2803 #endif
2804 {
2805 TRACE_EVENT ("blacklist is now full");
2806
2807 /* Blacklist is now full and
2808 MT shall prohibit further automatic call attempts
2809 */
2810 redial_stat = CM_REDIAL_ABORTED;
2811
2812
2813 /* allow a new outgoing */
2814 call_stat = MFW_CALL_FREE;
2815 call_type = MFW_CALL_FREE;
2816 cc_stat.type = MFW_CALL_FREE;
2817
2818 rdl.redial_mode = CM_REDIAL_BLACKLIST;
2819 cm_signal(E_CM_REDIAL, &rdl);
2820 #ifdef FF_MMI_OPTIM
2821 flash_MMI_blackList_close(file);
2822 #endif
2823 return;
2824 }
2825 #ifdef FF_MMI_OPTIM
2826 }
2827 flash_MMI_blackList_close(file);
2828 }
2829 #endif
2830
2831 /* check the registration staus */
2832 if (nm_reg_status() == MFW_NO_SERVICE)
2833 {
2834 call_stat = MFW_CALL_FREE;
2835 call_type = MFW_CALL_FREE;
2836 cc_stat.type = MFW_CALL_FREE;
2837
2838 rdl.redial_mode = CM_REDIAL_NO_SERVICE;
2839 cm_signal(E_CM_REDIAL, &rdl);
2840 return;
2841 }
2842
2843 TRACE_EVENT_P1("report = %d", extend_report);
2844 switch (extend_report)
2845 {
2846 case 28:
2847 // API - 1480 - Added this code to stop redial on an incorrect number
2848 if(!redial_count)
2849 {
2850 call_stat = MFW_CALL_FREE;
2851 call_type = MFW_CALL_FREE;
2852 cc_stat.type = MFW_CALL_FREE;
2853
2854 rdl.redial_mode = CM_REDIAL_ABORTED;
2855 cm_signal(E_CM_REDIAL, &rdl);
2856 return;
2857 }
2858 case 1: /* check whether the reason is in category 3 (GSM 02.07) */
2859 case 3:
2860 case 22:
2861 case 38:
2862 TRACE_EVENT ("category 3");
2863 if (!redial_count)
2864 {
2865 /* redial_count == 0;
2866 this is for the first outgoing call and
2867 now it is going to start the Auto-redial procedure
2868 */
2869 cc_stat.type = REDIALING_CALL;
2870 cc_stat.call_number = 0;
2871
2872 call_stat = REDIALING_CALL;
2873 rdl.redial_mode = CM_REDIAL_STARTED;
2874 mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
2875
2876 #ifdef NO_ASCIIZ
2877 rdl.name.len = cc_stat.name.len;
2878 memcpy(rdl.name.data,
2879 cc_stat.name.data,
2880 cc_stat.name.len);
2881 #else
2882 mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
2883 // strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
2884 #endif
2885 rdl.ton = cc_stat.ton;
2886 rdl.type = cc_stat.mode;
2887
2888 /* reasons in the category 3 have
2889 a call repeat attempts of max. 1 !
2890 */
2891 redial_count = MAX_REDIAL_ATTEMPT-1;
2892 cm_signal(E_CM_REDIAL, &rdl);
2893 return;
2894 }
2895 else
2896 redial_count = MAX_REDIAL_ATTEMPT;
2897 break;
2898
2899 case 17: /* check whether the reason is in category 1 and 2 (GSM 02.07) */
2900 case 18:
2901 case 19:
2902 case 27:
2903 case 34:
2904 case 41:
2905 case 42:
2906 case 44:
2907 case 47:
2908 TRACE_EVENT ("category 1 & 2");
2909 if (!redial_count)
2910 {
2911 /* redial_count == 0
2912 this is for the first outgoing call and
2913 now it is going to start the Auto-redial procedure
2914 */
2915 cc_stat.type = REDIALING_CALL;
2916 cc_stat.call_number = 0;
2917
2918 call_stat = REDIALING_CALL;
2919 rdl.redial_mode = CM_REDIAL_STARTED;
2920 mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
2921 #ifdef NO_ASCIIZ
2922 rdl.name.len = cc_stat.name.len;
2923 memcpy(rdl.name.data,
2924 cc_stat.name.data,
2925 cc_stat.name.len);
2926 #else
2927 mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
2928 // strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
2929 #endif
2930 rdl.ton = cc_stat.ton;
2931 rdl.type = cc_stat.mode;
2932
2933 /* reasons in the category 1 and 2 have
2934 a call repeat attempts of max. 10 !
2935 */
2936
2937 cm_signal(E_CM_REDIAL, &rdl);
2938 return;
2939 }
2940
2941 if (redial_count >= 1 AND redial_count <= 3)
2942 {
2943 timStart(redialTim24);
2944 call_stat = REDIALING_CALL;
2945 cc_stat.call_number = 0;
2946 return;
2947 }
2948
2949 if (redial_count >= 4 AND redial_count < MAX_REDIAL_ATTEMPT)
2950 {
2951 timStart(redialTim5);
2952 call_stat = REDIALING_CALL;
2953 cc_stat.call_number = 0;
2954 return;
2955 }
2956 #ifdef CUSTOMER_6366
2957 // JP PATCH The MMI needs to know if the 'error disconnect' has
2958 // resulted in redial starting irrespective of whether this was a redial attempt or not
2959 rdl.redial_mode = CM_REDIAL_STARTED;
2960 cm_signal(E_CM_REDIAL, &rdl);
2961 // END JP PATCH
2962 #endif /* CUSTOMER_6366 */
2963 break;
2964
2965 default:
2966 if (redial_count)
2967 {
2968 rdl.redial_mode = CM_REDIAL_STOP;
2969 mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
2970 #ifdef NO_ASCIIZ
2971 rdl.name.len = cc_stat.name.len;
2972 memcpy(rdl.name.data,
2973 cc_stat.name.data,
2974 cc_stat.name.len);
2975 #else
2976 mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);//???
2977 // strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
2978 #endif
2979 rdl.ton = cc_stat.ton;
2980 rdl.type = cc_stat.mode;
2981 cm_signal(E_CM_REDIAL, &rdl);
2982 }
2983 /* allow a new outgoing */
2984 call_stat = MFW_CALL_FREE;
2985 call_type = MFW_CALL_FREE;
2986 cc_stat.type = MFW_CALL_FREE;
2987 return;
2988 }
2989 #ifdef FF_MMI_OPTIM
2990 if (redial_count >= MAX_REDIAL_ATTEMPT
2991 AND count < MAX_BLACKLIST_NUM)
2992 {
2993 mfwStrncpy((char *)blackListNum,(char *)cc_stat.number, MFW_NUM_LEN);
2994 // Apr 14, 2005 REF: CRR 29991 xpradipg
2995 // once there is new addition update it onto the file
2996 if(flash_MMI_blackList_write((U8*)blackListNum, MFW_NUM_LEN, (count*MFW_NUM_LEN)+1) < 0)
2997 TRACE_FUNCTION("ERROR OPENING the blacklist file");
2998 count++;
2999 if(flash_MMI_blackList_write((U8*)&count,1,0) < 0)
3000 TRACE_FUNCTION("ERROR OPENING the blacklist file");
3001 #else
3002 if (redial_count >= MAX_REDIAL_ATTEMPT
3003 AND black_list.count < MAX_BLACKLIST_NUM)
3004 {
3005 mfwStrncpy((char *)black_list.number[black_list.count],
3006 (char *)cc_stat.number, MFW_NUM_LEN);
3007 black_list.count++;
3008 #endif
3009 rdl.redial_mode = CM_REDIAL_BLACKLISTED;
3010 mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
3011 #ifdef NO_ASCIIZ
3012 rdl.name.len = cc_stat.name.len;
3013 memcpy(rdl.name.data,
3014 cc_stat.name.data,
3015 cc_stat.name.len);
3016 #else
3017 mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
3018 // strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
3019 #endif
3020 rdl.ton = cc_stat.ton;
3021 rdl.type = cc_stat.mode;
3022 rdl.left_attempts = 0;
3023 cc_stat.call_number = 0;
3024 cm_signal(E_CM_REDIAL, &rdl);
3025 }
3026 }
3027
3028 /* allow a new outgoing */
3029 call_stat = MFW_CALL_FREE;
3030 call_type = MFW_CALL_FREE;
3031 cc_stat.type = MFW_CALL_FREE;
3032 }
3033 #endif
3034
3035
3036 /*
3037 +-----------------------------------------------------------------------+
3038 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
3039 | STATE : code ROUTINE : cm_rmt_error_connect |
3040 +-----------------------------------------------------------------------+
3041
3042
3043 PURPOSE : The connection is not successful
3044
3045 */
3046
3047 #ifdef FF_2TO1_PS
3048 void cm_rmt_error_connect(SHORT call_number)
3049 {
3050 T_CAUSE_ps_cause report; /* Marcus: Extended error reporting: 12/11/2002 */
3051
3052 TRACE_FUNCTION ("cm_error_connect()");
3053
3054 /* send event */
3055 dis_connect.call_number = call_number;
3056
3057 qAT_PlusCEER( CMD_SRC_LCL, &report);
3058 /* Marcus: Extended error reporting: 12/11/2002: Start */
3059 // TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report);
3060
3061 if (report.ctrl_value != CAUSE_is_from_nwcc)
3062 {
3063 /* Treat Condat defined cause values as if no cause given */
3064 dis_connect.cause = NOT_PRESENT_8BIT;
3065 }
3066 else
3067 {
3068 /* Standards defined cause value is given */
3069 dis_connect.cause = report.value.nwcc_cause;
3070 }
3071
3072 TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
3073 /* Marcus: Extended error reporting: 12/11/2002: End */
3074
3075 cm_signal(E_CM_DISCONNECT, &dis_connect);
3076 }
3077 #else
3078 void cm_rmt_error_connect(SHORT call_number)
3079 {
3080 USHORT report; /* Marcus: Extended error reporting: 12/11/2002 */
3081
3082 TRACE_FUNCTION ("cm_error_connect()");
3083
3084 /* send event */
3085 dis_connect.call_number = call_number;
3086
3087 qAT_PlusCEER( CMD_SRC_LCL, &report);
3088 /* Marcus: Extended error reporting: 12/11/2002: Start */
3089 TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report);
3090 if (GET_CAUSE_DEFBY(report) == DEFBY_CONDAT)
3091 {
3092 /* Treat Condat defined cause values as if no cause given */
3093 dis_connect.cause = NOT_PRESENT_8BIT;
3094 }
3095 else
3096 {
3097 /* Standards defined cause value is given */
3098 dis_connect.cause = GET_CAUSE_VALUE(report);
3099 }
3100 TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
3101 /* Marcus: Extended error reporting: 12/11/2002: End */
3102
3103 cm_signal(E_CM_DISCONNECT, &dis_connect);
3104 }
3105 #endif
3106
3107
3108 /*
3109 +--------------------------------------------------------------------+
3110 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
3111 | STATE : code ROUTINE: cm_disconnect |
3112 +--------------------------------------------------------------------+
3113
3114
3115 PURPOSE : Disconnection for outgoing call or active call
3116
3117 */
3118
3119 T_MFW cm_disconnect(SHORT call_number)
3120 {
3121 CHAR callId[5];
3122 T_MFW_CM_CALL_STAT stat;
3123 UBYTE ton;
3124 UBYTE mode;
3125
3126 TRACE_FUNCTION ("cm_disconnect()");
3127
3128 dis_connect.call_number = call_number;
3129
3130 if (!call_number)
3131 {
3132 cmd_hold = MFW_CM_MPTY_TERMINATED;
3133 sprintf(callId, "%d", 0);
3134 if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActSpec, callId) != AT_EXCT)
3135 return CM_ERROR;
3136 return CM_OK;
3137 }
3138
3139 cm_search_callStat(call_number, &stat, &ton, &mode);
3140
3141 TRACE_EVENT_P3("Status %d Ton %d Mode %d",stat,ton,mode);
3142
3143 /* HANG UP DATA CALL (WAP)
3144 * SPR#1983 - SH - Use sAT_Abort() when call has not yet connected,
3145 * rather than sAT_H */
3146
3147 if (mode == DATA_CALL)
3148 {
3149 T_ACI_RETURN retval;
3150
3151 TRACE_EVENT_P1("***Disconnect data call, stat=%d", stat);
3152
3153 if ((stat == CALL_DIAL) OR (stat == CALL_ALERT))
3154 {
3155 if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) NEQ AT_CMPL)
3156 return CM_ERROR;
3157 return CM_OK;
3158 }
3159
3160 if (stat == CALL_DEACTIVE && currConnecting) /* ES/AK 290999 */
3161 {
3162 currConnecting = 0;
3163 if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) NEQ AT_CMPL)
3164 return CM_ERROR;
3165 return CM_OK;
3166 }
3167
3168 retval = sAT_H(CMD_SRC_LCL);
3169
3170 TRACE_EVENT_P1("Result of sAT_H = %d", retval);
3171 if (retval)
3172 return CM_ERROR;
3173 return CM_OK;
3174 }
3175
3176
3177 if ((stat == CALL_DIAL) OR (stat == CALL_ALERT))
3178 {
3179 if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) NEQ AT_CMPL)
3180 return CM_ERROR;
3181 return CM_OK;
3182 }
3183
3184 if (stat == CALL_DEACTIVE && currConnecting) /* ES/AK 290999 */
3185 {
3186 currConnecting = 0;
3187 if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) NEQ AT_CMPL)
3188 return CM_ERROR;
3189 return CM_OK;
3190 }
3191
3192 if ((stat == CALL_ACTIVE) OR (stat == CALL_DEACTIVE))
3193 {
3194 cmd_hold = MFW_CM_TERMINATED;
3195 sprintf(callId, "%d", call_number);
3196 if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActSpec, callId) != AT_EXCT)
3197 return CM_ERROR;
3198 return CM_OK;
3199 }
3200 else if (stat == CALL_HELD)
3201 {
3202
3203
3204 // Apr 26, 2004 REF: CRR 16545 Ajith K P Side effect of CRR 16545.
3205 // CHLD_MOD_RelActSpec no longer releases held calls.
3206 // So now if the user wants to release a HELD call, now we are calling the
3207 // sAT_PlusCHLD(..) function with CHLD_MOD_RelAnySpec as the parameter.
3208
3209
3210
3211 cmd_hold = MFW_CM_TERMINATED;
3212 sprintf(callId, "%d", call_number);
3213 // Feb 27, 2006 REF:DR OMAPS00067884 x0039928
3214 // Fix : sAT_PercentCHLD() is called if the mode > CHLD_MOD_RelDialCall
3215 if (sAT_PercentCHLD(CMD_SRC_LCL, CHLD_MOD_RelAnySpec, callId) != AT_EXCT)
3216 return CM_ERROR;
3217 return CM_OK;
3218 }
3219 return CM_ERROR;
3220 }
3221
3222 /*
3223 +--------------------------------------------------------------------+
3224 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
3225 | STATE : code ROUTINE: cm_force_disconnect |
3226 +--------------------------------------------------------------------+
3227
3228
3229 PURPOSE : Disconnection of any call existent needed for Multiparty and some structured procedures
3230 call termination in state U9
3231
3232 */
3233
3234 void cm_force_disconnect(void)
3235 {
3236 T_ACI_RETURN res;
3237
3238 TRACE_FUNCTION("cm_force_disconnect()");
3239
3240 res = sAT_H(CMD_SRC_LCL);
3241 if (res != AT_EXCT && res != AT_CMPL)
3242 TRACE_ERROR("satReject() error");
3243
3244 return;
3245 }
3246
3247
3248 /*
3249 +--------------------------------------------------------------------+
3250 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
3251 | STATE : code ROUTINE: cm_ok_disconnect |
3252 +--------------------------------------------------------------------+
3253
3254
3255 PURPOSE : indicates disconnection from called party;
3256 sends E_CM_DISCONNECT to mmi
3257
3258 */
3259
3260 #ifdef FF_2TO1_PS
3261 void cm_ok_disconnect(T_ACI_CMD_SRC src, SHORT call_id)
3262 {
3263 T_CAUSE_ps_cause cause; /* Marcus: Extended error reporting: 12/11/2002 */
3264 T_MFW_CM_DISCONNECT_ALL disconnect_all;
3265
3266 TRACE_FUNCTION("cm_ok_disconnect()");
3267
3268 TRACE_EVENT_P4("dis_connect.call_number %d, cmd_hold %d, src %d, call_id %d",
3269 dis_connect.call_number, cmd_hold, src, call_id);
3270
3271
3272
3273
3274 /* Marcus: CCBS: 14/11/2002: Start */
3275 if (cmd_hold == MFW_CM_CCBS_REGISTER)
3276 {
3277 /* Rejecting the offered CCBS registration */
3278 TRACE_EVENT("cmd_hold == MFW_CM_CCBS_REGISTER");
3279 cmd_hold = 0;
3280 cm_ccbs_ok();
3281 return;
3282 }
3283 /* Marcus: CCBS: 14/11/2002: End */
3284
3285 if (cmd_hold == MFW_CM_MPTY_TERMINATED)
3286 dis_connect.call_number = 0;
3287 //Nov 02, 2005 DR OMAPS00052132 xdeepadh
3288 //The usage of ATI enum is put under the flag FF_ATI
3289 #if defined (FF_ATI) || defined (NEPTUNE_BOARD)
3290 else if (src EQ CMD_SRC_ATI_1) /* NM Berlin/UK integration 21.09.01 */
3291 {
3292 dis_connect.call_number = call_id;
3293 }
3294 #endif
3295
3296
3297 /* send event */
3298 qAT_PlusCEER( CMD_SRC_LCL, &cause);
3299 /* Marcus: Extended error reporting: 12/11/2002: Start */
3300 // TRACE_EVENT_P1("qAT_PlusCEER(%04X)", cause);
3301
3302 if (cause.ctrl_value != CAUSE_is_from_nwcc)
3303 {
3304 /* Treat Condat defined cause values as if no cause given */
3305 dis_connect.cause = NOT_PRESENT_8BIT;
3306 }
3307 else
3308 {
3309 /* Standards defined cause value is given */
3310 dis_connect.cause = cause.value.nwcc_cause;
3311 }
3312
3313 TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
3314 /* Marcus: Extended error reporting: 12/11/2002: End */
3315
3316 /* allow a new outgoing */
3317 call_stat = MFW_CALL_FREE;
3318 call_type = MFW_CALL_FREE;
3319
3320 if (cmd_hold EQ MFW_CM_DISCONNECT_ALL)
3321 {
3322 disconnect_all.result = CM_DISCONNECT_ALL_RESULT_OK;
3323 if (cause.ctrl_value != CAUSE_is_from_nwcc)
3324 {
3325 /* Treat Condat defined cause values as if no cause given */
3326 disconnect_all.cause = NOT_PRESENT_8BIT;
3327 }
3328 else
3329 {
3330 /* Standards defined cause value is given */
3331 disconnect_all.cause = cause.value.nwcc_cause;
3332 }
3333 cm_signal(E_CM_DISCONNECT_ALL,&disconnect_all);
3334 }
3335 else
3336 cm_signal(E_CM_DISCONNECT, &dis_connect);
3337
3338 cmd_hold = 0;
3339
3340 }
3341 #else
3342 void cm_ok_disconnect(T_ACI_CMD_SRC src, SHORT call_id)
3343 {
3344 USHORT cause; /* Marcus: Extended error reporting: 12/11/2002 */
3345 T_MFW_CM_DISCONNECT_ALL disconnect_all;
3346
3347 TRACE_FUNCTION("cm_ok_disconnect()");
3348
3349 TRACE_EVENT_P4("dis_connect.call_number %d, cmd_hold %d, src %d, call_id %d",
3350 dis_connect.call_number, cmd_hold, src, call_id);
3351
3352
3353
3354
3355 /* Marcus: CCBS: 14/11/2002: Start */
3356 if (cmd_hold == MFW_CM_CCBS_REGISTER)
3357 {
3358 /* Rejecting the offered CCBS registration */
3359 TRACE_EVENT("cmd_hold == MFW_CM_CCBS_REGISTER");
3360 cmd_hold = 0;
3361 cm_ccbs_ok();
3362 return;
3363 }
3364 /* Marcus: CCBS: 14/11/2002: End */
3365
3366 if (cmd_hold == MFW_CM_MPTY_TERMINATED)
3367 dis_connect.call_number = 0;
3368 //Nov 02, 2005 DR OMAPS00052132 xdeepadh
3369 //The usage of ATI enum is put under the flag FF_ATI
3370 #ifdef FF_ATI
3371 else if (src EQ CMD_SRC_ATI_1) //NM Berlin/UK integration 21.09.01
3372 {
3373 dis_connect.call_number = call_id;
3374 }
3375 #endif //FF_ATI
3376
3377 /* send event */
3378 qAT_PlusCEER( CMD_SRC_LCL, &cause);
3379 /* Marcus: Extended error reporting: 12/11/2002: Start */
3380 TRACE_EVENT_P1("qAT_PlusCEER(%04X)", cause);
3381 if (GET_CAUSE_DEFBY(cause) == DEFBY_CONDAT)
3382 {
3383 /* Treat Condat defined cause values as if no cause given */
3384 dis_connect.cause = NOT_PRESENT_8BIT;
3385 }
3386 else
3387 {
3388 /* Standards defined cause value is given */
3389 dis_connect.cause = GET_CAUSE_VALUE(cause);
3390 }
3391 TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause);
3392 /* Marcus: Extended error reporting: 12/11/2002: End */
3393
3394 /* allow a new outgoing */
3395 call_stat = MFW_CALL_FREE;
3396 call_type = MFW_CALL_FREE;
3397
3398 if (cmd_hold EQ MFW_CM_DISCONNECT_ALL)
3399 {
3400 disconnect_all.result = CM_DISCONNECT_ALL_RESULT_OK;
3401 if (GET_CAUSE_DEFBY(cause) == DEFBY_CONDAT)
3402 {
3403 /* Treat Condat defined cause values as if no cause given */
3404 disconnect_all.cause = NOT_PRESENT_8BIT;
3405 }
3406 else
3407 {
3408 /* Standards defined cause value is given */
3409 disconnect_all.cause = GET_CAUSE_VALUE(cause);
3410 }
3411 cm_signal(E_CM_DISCONNECT_ALL,&disconnect_all);
3412 }
3413 else
3414 cm_signal(E_CM_DISCONNECT, &dis_connect);
3415
3416 cmd_hold = 0;
3417
3418 }
3419 #endif
3420
3421 /* Marcus: CCBS: 14/11/2002: Start */
3422 /*
3423 +--------------------------------------------------------------------+
3424 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
3425 | STATE : code ROUTINE: cm_error_disconnect |
3426 +--------------------------------------------------------------------+
3427
3428 PURPOSE : indicates failed disconnection
3429
3430 */
3431 void cm_error_disconnect(void)
3432 {
3433 TRACE_FUNCTION ("cm_error_disconnect()");
3434 if (cmd_hold == MFW_CM_DISCONNECT_ALL)
3435 {
3436 TRACE_EVENT("cmd_hold == MFW_CM_DISCONNECT_ALL");
3437 cmd_hold = 0;
3438 }
3439
3440 /* Marcus: CCBS: 14/11/2002: Start */
3441 if (cmd_hold == MFW_CM_CCBS_REGISTER)
3442 {
3443 TRACE_EVENT("cmd_hold == MFW_CM_CCBS_REGISTER");
3444 /* Rejecting the offered CCBS registration */
3445 cmd_hold = 0;
3446 cm_ccbs_error();
3447 }
3448 }
3449 /* Marcus: CCBS: 14/11/2002: End */
3450
3451 /*
3452 +--------------------------------------------------------------------+
3453 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
3454 | STATE : code ROUTINE: cm_command |
3455 +--------------------------------------------------------------------+
3456
3457
3458 PURPOSE :
3459
3460 */
3461
3462 T_MFW cm_command(SHORT call_number, UBYTE command, UBYTE crss_string)
3463 {
3464 CHAR callId[5];
3465 UBYTE res;
3466 SHORT retVal, modeRetVal; // xnkulkar SPR-18262: Added "modeRetVal" to store the return value of "mfw_cbuf_put_mode ()"
3467
3468 TRACE_FUNCTION ("cm_command()");
3469
3470 // JP PATCH
3471 cmd_hold = 0;
3472 // END PATCH
3473
3474 cmd.call_number = call_number;
3475 cmd.command = command;
3476
3477 switch (command)
3478 {
3479 case CM_HOLD:
3480 case CM_SWAP:
3481 case CM_RETRIEVE:
3482 case CM_SWAP_MULTIPARTY:
3483 case CM_HOLD_MULTIPARTY:
3484 case CM_RETRIEVE_MULTIPARTY:
3485 /* place all active calls on held and accept held or waiting call */
3486 if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_HldActAndAcpt, 0) != AT_EXCT)
3487 return FALSE;
3488 break;
3489
3490 case CM_BUILD_MULTIPARTY:
3491 if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_AddHld, 0)!= AT_EXCT)
3492 return FALSE;
3493 break;
3494
3495 case CM_SPLIT_MULTIPARTY:
3496 if (call_number <= 0)
3497 return FALSE;
3498 sprintf(callId, "%d", call_number);
3499 if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_HldActExc, callId)!= AT_EXCT)
3500 return FALSE;
3501 break;
3502
3503 case CM_ETC:
3504 /* connects two calls and disconnects the subsrciber from both calls */
3505 if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_Ect, 0) != AT_EXCT)
3506 return FALSE;
3507 break;
3508
3509 case CM_CALL_DEFLECTION:
3510 break;
3511
3512 case CM_CCBS:
3513 TRACE_EVENT("CM_CCBS");
3514 sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_Ccbs, 0);
3515 break;
3516
3517 case CM_MODIFY:
3518 break;
3519
3520 case CM_DTMF_ACTIVE:
3521 // xnkulkar SPR-18262
3522 // If there is a DTMF tone command already in the queue, add the current tone also
3523 // in the queue (with start mode). While attempting to send a tone, if the request is not successful,
3524 // add the DTMF request to the queue. Also, start adding to the queue if we are expecting an acknowledgement
3525 // (rAT_OK) for the previous DTMF tone request sent.
3526 if (mfw_cbuf_num_elements(mfw_cm_dtmf_q_id) != 0)
3527 {
3528 /*
3529 ** There are already DTMF tones queued to be sent, so queue this request too along with the mode (Start).
3530 */
3531 modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_ManStart);
3532 retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string);
3533 // If the return values are negative, attempt to Queue the DTMF request failed
3534 if (retVal < 0 || modeRetVal < 0)
3535 {
3536 TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal);
3537 TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal);
3538 /*
3539 ** Failed to Queue the DTMF request.
3540 */
3541 return(FALSE);
3542 }
3543 }
3544 else
3545 {
3546 //xnkulkar 18262
3547 // While attempting to send a tone, if the command is not successfully completed, add
3548 // the request to the queue. After sending a DTMF tone comand, set the variable expectRatOk to true.
3549 // This will be reset only when all the DTMF tones in queue are sent.
3550 if ( expectRatOk == TRUE || sAT_PlusVTS(CMD_SRC_LCL, (CHAR)crss_string, VTS_MOD_ManStart) != AT_EXCT)
3551 {
3552 /*
3553 ** The attempt to send an immediate DTMF failed.
3554 ** Add the failed attempt onto the DTMF queue and wait.
3555 */
3556 // xnkulkar 18262
3557 // Also store the "mode"(Start), in which the DTMF tone has to be sent.
3558 // This is stored in the queue in an array.
3559 modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_ManStart);
3560 retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string);
3561 if (retVal < 0 || modeRetVal < 0 )
3562 {
3563 TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal);
3564 TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal);
3565 /*
3566 ** Failed to Queue the DTMF request.
3567 */
3568 return(FALSE);
3569 }
3570 }
3571 expectRatOk = TRUE; // xnkulkar SPR-18262: Set this flag to TRUE
3572 }
3573 currCmd = AT_CMD_VTS;
3574 break;
3575
3576 case CM_DTMF_INACTIVE:
3577 // xnkulkar SPR-18262
3578 // If there is a DTMF tone command already in the queue, add the current tone also
3579 // in the queue (with stop mode). While attempting to send a tone, if the request is not successful,
3580 // add the DTMF request to the queue. Also, start adding to the queue if we are expecting an acknowledgement
3581 // (rAT_OK) for the previous DTMF tone request sent.
3582 if (mfw_cbuf_num_elements(mfw_cm_dtmf_q_id) != 0)
3583 {
3584 /*
3585 ** There are already DTMF tones queued to be sent, so queue this request too along with the mode (Stop).
3586 */
3587 modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_ManStop);
3588 retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string);
3589 if (retVal < 0 || modeRetVal < 0)
3590 {
3591 TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal);
3592 TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal);
3593 /*
3594 ** Failed to Queue the DTMF request.
3595 */
3596 return(FALSE);
3597 }
3598 }
3599 else
3600 {
3601 if (expectRatOk == TRUE || sAT_PlusVTS(CMD_SRC_LCL, (CHAR)crss_string, VTS_MOD_ManStop) != AT_EXCT)
3602 {
3603 /*
3604 ** The attempt to send an immediate DTMF failed.
3605 ** Add the failed attempt onto the DTMF queue and wait.
3606 */
3607 modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_ManStop);
3608 retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string);
3609 if (retVal < 0 || modeRetVal < 0)
3610 {
3611 TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal);
3612 TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal);
3613 /*
3614 ** Failed to Queue the DTMF request.
3615 */
3616 return(FALSE);
3617 }
3618 }
3619 expectRatOk = TRUE; //xnkulkar SPR-18262: set this flag to TRUE
3620 }
3621 res = TRUE;
3622 cm_signal(E_CM_DTMF, &res);
3623 break;
3624
3625 case CM_DTMF_AUTO:
3626 if (mfw_cbuf_num_elements(mfw_cm_dtmf_q_id) != 0)
3627 {
3628 /*
3629 ** There are already DTMF tones queued to be sent, so queue this request to.
3630 */
3631 modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_Auto);
3632 retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string);
3633 if (retVal < 0 || modeRetVal < 0)
3634 {
3635 TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal);
3636 TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal);
3637 /*
3638 ** Failed to Queue the DTMF request.
3639 */
3640 return(FALSE);
3641 }
3642 }
3643 else
3644 {
3645 if (sAT_PlusVTS(CMD_SRC_LCL, (CHAR)crss_string, VTS_MOD_Auto) != AT_EXCT)
3646 {
3647 /*
3648 ** The attempt to send an immediate DTMF failed.
3649 ** Add the failed attempt onto the DTMF queue and wait.
3650 */
3651 modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_Auto);
3652 retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string);
3653 if (retVal < 0 || modeRetVal < 0)
3654 {
3655 TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal);
3656 TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal);
3657 /*
3658 ** Failed to Queue the DTMF request.
3659 */
3660 return(FALSE);
3661 }
3662 }
3663 }
3664 break;
3665
3666 default:
3667 break;
3668 }
3669 return TRUE;
3670 }
3671
3672
3673 /*
3674 +--------------------------------------------------------------------+
3675 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
3676 | STATE : code ROUTINE : send_queued_dtmf_tone |
3677 +--------------------------------------------------------------------+
3678
3679
3680 PURPOSE : Check the DTMF Queue and if required send the next DTMF Tone Request.
3681
3682 */
3683 static void send_queued_dtmf_tone(void)
3684 {
3685 SHORT retVal;
3686 UBYTE qdtmf;
3687 //xnkulkar SPR-18262: Added these variables to store the Mode
3688 T_ACI_VTS_MOD vts_mode = VTS_MOD_NotPresent;
3689
3690 TRACE_FUNCTION("send_queued_dtmf_tone()");
3691
3692 // If there are DTMF tones to be sent in the queue
3693 if (mfw_cbuf_num_elements(mfw_cm_dtmf_q_id) > 0)
3694 {
3695 // Get the mode (Start / Stop) corresponding to the DTMF tone
3696 vts_mode = (T_ACI_VTS_MOD)mfw_cbuf_get_mode(mfw_cm_dtmf_q_id);
3697 // Get the DTMF key for which the tone is to be sent from the queue
3698 retVal = mfw_cbuf_get(mfw_cm_dtmf_q_id, &qdtmf);
3699 if (retVal > 0)
3700 {
3701 if (sAT_PlusVTS(CMD_SRC_LCL, (CHAR)qdtmf, vts_mode) != AT_EXCT)
3702 {
3703 /*
3704 ** The attempt to send an immediate DTMF failed
3705 */
3706 TRACE_EVENT("ERROR : Attempt to send a queued DTMF tone failed!!!!");
3707 }
3708 }
3709 else
3710 {
3711 TRACE_EVENT_P1("ERROR : mfw_cbuf_get failed with error value %d", retVal);
3712 }
3713 }
3714 else
3715 {
3716 // xnkulkar SPR-18262: if number of elements in queue is zero, we can start sending
3717 // DTMF so reset this variable.
3718 expectRatOk = FALSE;
3719 }
3720 }
3721
3722 /*
3723 +--------------------------------------------------------------------+
3724 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
3725 | STATE : code ROUTINE : cm_ok_dtmf |
3726 +--------------------------------------------------------------------+
3727
3728
3729 PURPOSE : DTMF activation is successful.
3730
3731 */
3732
3733 void cm_ok_dtmf(void)
3734 {
3735 UBYTE res;
3736
3737 currCmd = AT_CMD_NONE;
3738 res = TRUE;
3739 cm_signal(E_CM_DTMF, &res);
3740
3741 send_queued_dtmf_tone();
3742
3743 return;
3744 }
3745
3746
3747 /*
3748 +--------------------------------------------------------------------+
3749 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
3750 | STATE : code ROUTINE : cm_error_tdmf |
3751 +--------------------------------------------------------------------+
3752
3753
3754 PURPOSE : DTMF activation is failed.
3755
3756 */
3757
3758 void cm_error_dtmf(void)
3759 {
3760 UBYTE res;
3761
3762 currCmd = AT_CMD_NONE;
3763 res = FALSE;
3764 cm_signal(E_CM_DTMF, &res);
3765
3766 send_queued_dtmf_tone();
3767
3768 }
3769
3770
3771 /*
3772 +--------------------------------------------------------------------+
3773 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
3774 | STATE : code ROUTINE : cm_result_cmd |
3775 +--------------------------------------------------------------------+
3776
3777
3778 PURPOSE : Acknowledgement for the requested ss command.
3779
3780 */
3781
3782 void cm_result_cmd(T_ACI_CMD_SRC src, UBYTE result)
3783 {
3784 SHORT call_number;
3785
3786 TRACE_EVENT_P1("cm_result_cmd(), cmd_hold = %d", cmd_hold);
3787
3788 /* MC changed all the "if"s to a switch to allow default 11/04/02*/
3789 switch (cmd_hold)
3790 {
3791 case MFW_CM_MT_REJECT:
3792 break; /* CONQUEST 6040- MC- put a break in the case so no action taken*/
3793 case MFW_CM_MPTY_TERMINATED:
3794 case MFW_CM_TERMINATED:
3795
3796 {
3797 if (result EQ Present)
3798 cm_ok_disconnect(CMD_SRC_LCL, 0);
3799 return;
3800 }
3801 // break; // RAVI
3802
3803 case MFW_CM_MT_ACCEPT:
3804 {
3805 /*
3806 * active call on hold, accept new incoming call
3807 */
3808 cmd_hold = 0;
3809 if (result EQ Present)
3810 /*
3811 * Call on hold was successful
3812 */
3813 cm_ok_connect();
3814
3815 else
3816 {
3817 if (cm_search_callId(CAL_STAT_Active, &call_number) != CM_OK)
3818 return;
3819 cmd.call_number = call_number;
3820 cc_id = 0; // ???
3821 }
3822 }
3823 break;
3824
3825
3826 case MFW_CM_HOLD_AND_DIAL:
3827 {
3828 /*
3829 * active call on hold, accept new incoming call
3830 */
3831 cmd_hold = 0;
3832 if (result EQ Present)
3833 /*
3834 * Call on hold was successful
3835 */
3836 cm_ok_connect();
3837
3838 else
3839 {
3840 if (cm_search_callId(CAL_STAT_Active, &call_number) != CM_OK)
3841 return;
3842 cmd.call_number = call_number;
3843 cc_id = 0; // ???
3844 }
3845 }
3846 break;
3847
3848 case MFW_CM_1_SEND:
3849 {
3850
3851 cmd_hold = 0;
3852 if (result == Present)
3853 {
3854 // MMI-SPR 13873 xkundadu
3855 // Handling of 1SEND
3856 // If the user presses 1SEND, release active calls and accept
3857 // the WAITING call
3858 if (dis_connect.call_number NEQ -1)
3859 {
3860 // If there is an active call, disconnect it.
3861 cm_ok_disconnect(CMD_SRC_LCL, 0);
3862 }
3863
3864 if (!cmd.call_number)
3865 {
3866 // If there is waiting call, accept the call
3867 cm_ok_connect();
3868 }
3869 cmd.call_number = -1;
3870 }
3871
3872 }
3873 break;
3874
3875 /* Marcus: CCBS: 14/11/2002: Start */
3876 case MFW_CM_CCBS_REGISTER:
3877
3878 TRACE_EVENT("MFW_CM_CCBS_REGISTER");
3879
3880 cmd_hold = 0;
3881
3882 if (result == Present)
3883 {
3884 TRACE_EVENT("result == Present");
3885 cm_ccbs_ok();
3886 }
3887 else /* result is NotPresent */
3888 {
3889 TRACE_EVENT("result != Present");
3890 cm_ccbs_error();
3891 }
3892 return;
3893
3894 case MFW_CM_CCBS_RECALL:
3895
3896 TRACE_EVENT("MFW_CM_CCBS_RECALL");
3897
3898 cmd_hold = 0;
3899
3900 if (result == Present)
3901 {
3902 TRACE_EVENT("result == Present");
3903 cm_ccbs_ok();
3904 }
3905 else /* result is NotPresent */
3906 {
3907 TRACE_EVENT("result != Present");
3908 cm_ccbs_error();
3909 }
3910 return;
3911 /* Marcus: CCBS: 14/11/2002: Start */
3912
3913 default:/*For other command types ensure correct result is passed up to BMI*/
3914 {
3915 cmd.result = result;
3916 }
3917 break;
3918 }
3919
3920
3921 #if defined (WIN32)
3922 {
3923 char buf[40];
3924 sprintf (buf, "Event CM_COMMAND for %d", cmd.call_number);
3925 TRACE_EVENT (buf);
3926 sprintf (buf, "Result %d Command %d",cmd.result, cmd.command);
3927 TRACE_EVENT (buf);
3928 }
3929 #endif
3930 cmd.result = result;
3931 cm_signal(E_CM_COMMAND, &cmd);
3932 }
3933
3934
3935 /*
3936 +--------------------------------------------------------------------+
3937 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
3938 | STATE : code ROUTINE: cm_cvt_speed_type |
3939 +--------------------------------------------------------------------+
3940
3941
3942 PURPOSE : This function is used to convert the type of data rate
3943 used by MFW to the type of data rate used by ACI.
3944
3945 */
3946
3947 LOCAL T_ACI_BS_SPEED cm_cvt_speed_type ( T_MFW_CM_DATA_SPEED speed )
3948 {
3949 switch ( speed )
3950 {
3951 case ( SPEED_300 ): return BS_SPEED_300_V110;
3952 case ( SPEED_1200 ): return BS_SPEED_1200_V110;
3953 case ( SPEED_2400 ): return BS_SPEED_2400_V110;
3954 case ( SPEED_4800 ): return BS_SPEED_4800_V110;
3955 case ( SPEED_9600 ): return BS_SPEED_9600_V110;
3956 case ( SPEED_14400 ): return BS_SPEED_14400_V110;
3957 default: return BS_SPEED_NotPresent;
3958 }
3959 }
3960
3961
3962 /*
3963 +--------------------------------------------------------------------+
3964 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
3965 | STATE : code ROUTINE: cm_cvt_bs_type |
3966 +--------------------------------------------------------------------+
3967
3968
3969 PURPOSE : This function is used to convert the type of bearer service
3970 used by MFW to the type of bearer service used by ACI.
3971
3972 */
3973
3974 LOCAL T_ACI_CBST_NAM cm_cvt_bs_type ( T_MFW_CM_BS bs )
3975 {
3976 switch ( bs )
3977 {
3978 case ( Asynch ): return CBST_NAM_Asynch;
3979 case ( Synch ): return CBST_NAM_Synch;
3980 default: return CBST_NAM_NotPresent;
3981 }
3982 }
3983
3984
3985 /*
3986 +--------------------------------------------------------------------+
3987 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
3988 | STATE : code ROUTINE: cm_cvt_ce_type |
3989 +--------------------------------------------------------------------+
3990
3991
3992 PURPOSE : This function is used to convert the data mode
3993 used by MFW to the data mode used by ACI.
3994
3995 */
3996
3997 LOCAL T_ACI_CBST_CE cm_cvt_ce_type ( T_MFW_CM_CE ce )
3998 {
3999 switch ( ce )
4000 {
4001 case ( Transparent ): return CBST_CE_Transparent;
4002 case ( NonTransparent ): return CBST_CE_NonTransparent;
4003 default: return CBST_CE_NotPresent;
4004 }
4005 }
4006
4007 /*
4008 +--------------------------------------------------------------------+
4009 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
4010 | STATE : code ROUTINE: cm_set_bc_para |
4011 +--------------------------------------------------------------------+
4012
4013
4014 PURPOSE : Set bearer parameter for mobile originated calls.
4015
4016 */
4017
4018 void cm_set_bc_para(T_MFW_CM_BC_PARA * bc, UBYTE ti)
4019 {
4020 TRACE_FUNCTION ("cm_set_bc_para()");
4021
4022 sAT_PlusCBST(CMD_SRC_LCL,
4023 cm_cvt_speed_type ((T_MFW_CM_DATA_SPEED)bc->rate),
4024 cm_cvt_bs_type ((T_MFW_CM_BS)bc->bearer_serv),
4025 cm_cvt_ce_type ((T_MFW_CM_CE)bc->conn_elem));
4026 }
4027
4028
4029 /*
4030 +--------------------------------------------------------------------+
4031 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
4032 | STATE : code ROUTINE: cm_notify |
4033 +--------------------------------------------------------------------+
4034
4035
4036 PURPOSE : Change of SS status from call party.
4037
4038 */
4039 void cm_notify(T_ACI_CSSU_CODE code,
4040 SHORT index,
4041 UBYTE *number)
4042 { char debug[50];
4043 sprintf(debug,"cm_notify(), code:%d, index:%d" , code, index);
4044 TRACE_EVENT(debug);
4045 if (number)
4046 notify.call_number = index;
4047
4048 if (code == CSSU_CODE_OnHold)
4049 notify.notification = MFW_CM_HOLD;
4050 if (code == CSSU_CODE_Retrieved)
4051 notify.notification = MFW_CM_RETRIEVED;
4052
4053 cm_signal(E_CM_NOTIFY, &notify);
4054 }
4055
4056
4057 /*
4058 +--------------------------------------------------------------------+
4059 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
4060 | STATE : code ROUTINE : cm_get_aoc_value |
4061 +--------------------------------------------------------------------+
4062
4063
4064 PURPOSE : Getting AoC (advice of charge) value.
4065
4066 */
4067
4068 T_MFW cm_get_aoc_value(UBYTE request_type, T_MFW_CM_AOC_INFO *aoc_info)
4069 {
4070 T_ACI_RPCT_VAL rpuct;
4071
4072 TRACE_FUNCTION ("cm_get_aoc_value()");
4073
4074 switch (request_type)
4075 {
4076 /* Price pro unit and currency table */
4077 case CM_AOC_PUCT:
4078 if (qAT_PlusCPUC(CMD_SRC_LCL,
4079 (CHAR *)aoc_info->cur,
4080 (CHAR *)aoc_info->ppu) == AT_CMPL)
4081 {
4082 aoc_info->requested_type = CM_AOC_PUCT;
4083 return CM_OK;
4084 }
4085 else
4086 return CM_NO_AOC;
4087 // break; // RAVI
4088
4089 /* maximum value of accumulated Call Meter */
4090 case CM_AOC_ACMMAX:
4091 if (qAT_PlusCAMM(CMD_SRC_LCL, &aoc_info->acm_max) == AT_CMPL)
4092 {
4093 aoc_info->requested_type = CM_AOC_ACMMAX;
4094 return CM_OK;
4095 }
4096 else
4097 return CM_NO_AOC;
4098 // break; // RAVI
4099
4100 /* Accumulated Call Meter */
4101 case CM_AOC_ACM:
4102 if (qAT_PlusCACM(CMD_SRC_LCL, &aoc_info->acm) == AT_CMPL)
4103 {
4104 aoc_info->requested_type = CM_AOC_ACM;
4105 return CM_OK;
4106 }
4107 else
4108 return CM_NO_AOC;
4109 // break; // RAVI
4110
4111 case CM_AOC_CCM:
4112 if (qAT_PlusCAOC(CMD_SRC_LCL, &aoc_info->ccm) == AT_CMPL)
4113 {
4114 aoc_info->requested_type = CM_AOC_CCM;
4115 return CM_OK;
4116 }
4117 else
4118 return CM_NO_AOC;
4119 // break; // RAVI
4120
4121 case CM_AOC_TIMERS:
4122 if (qAT_PercentCTV(CMD_SRC_LCL, &aoc_info->actual_call_timer) == AT_CMPL)
4123 {
4124 aoc_info->requested_type = CM_AOC_TIMERS;
4125 return CM_OK;
4126 }
4127 else
4128 return CM_NO_AOC;
4129 // break; // RAVI
4130
4131 case CM_AOC_CCM_PUCT:
4132 if (qAT_PercentCAOC(CMD_SRC_LCL, (CHAR *)aoc_info->cur, (CHAR *)aoc_info->ccm_puct) == AT_CMPL)
4133 {
4134 aoc_info->requested_type = CM_AOC_CCM_PUCT;
4135 return CM_OK;
4136 }
4137 else
4138 return CM_NO_AOC;
4139 // break; // RAVI
4140
4141 case CM_AOC_ACM_PUCT:
4142 if (qAT_PercentCACM(CMD_SRC_LCL, (CHAR *)aoc_info->cur, (CHAR *)aoc_info->acm_puct) == AT_CMPL)
4143 {
4144 aoc_info->requested_type = CM_AOC_ACM_PUCT;
4145 return CM_OK;
4146 }
4147 else
4148 return CM_NO_AOC;
4149 case CM_AOC_RAW_PUCT:
4150 if (qAT_PercentRPCT(CMD_SRC_LCL, &rpuct) == AT_CMPL)
4151 {
4152 aoc_info->requested_type = CM_AOC_RAW_PUCT;
4153 strncpy((char *)aoc_info->cur, (char *)rpuct.currency, MAX_CUR_LEN);
4154 aoc_info->eppu = rpuct.eppu;
4155 aoc_info->exp = rpuct.exp;
4156 aoc_info->sexp = rpuct.sexp;
4157 return CM_OK;
4158 }
4159 else
4160 return CM_NO_AOC;
4161 // break; // RAVI
4162
4163 default:
4164 return CM_NO_AOC;
4165 }
4166 }
4167
4168
4169
4170 /*
4171 +----------------------------------------------------------------------+
4172 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
4173 | STATE : code ROUTINE : cm_reset_aoc_value |
4174 +----------------------------------------------------------------------+
4175
4176
4177 PURPOSE : Setting AoC (advice of charge) value.
4178
4179 */
4180
4181 T_MFW cm_set_aoc_value(UBYTE request_type,
4182 T_MFW_CM_AOC_INFO *aoc_info,
4183 UBYTE *pwd)
4184 {
4185 TRACE_FUNCTION ("cm_reset_aoc_value()");
4186
4187 switch (request_type)
4188 {
4189 case CM_AOC_PUCT:
4190 if (sAT_PlusCPUC(CMD_SRC_LCL, (CHAR *)aoc_info->cur,
4191 (CHAR *)aoc_info->ppu, (CHAR *)pwd) != AT_EXCT)
4192 return CM_ERROR;
4193 break;
4194
4195 case CM_AOC_ACMMAX:
4196 if (sAT_PlusCAMM(CMD_SRC_LCL, aoc_info->acm_max,
4197 (CHAR *)pwd) != AT_EXCT)
4198 return CM_ERROR;
4199 break;
4200
4201 case CM_AOC_ACM:
4202 if (sAT_PlusCACM(CMD_SRC_LCL, (CHAR *)pwd) != AT_EXCT)
4203 return CM_ERROR;
4204 break;
4205
4206 default:
4207 return CM_ERROR;
4208 }
4209
4210 return CM_OK;
4211 }
4212
4213
4214 /*
4215 +----------------------------------------------------------------------+
4216 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
4217 | STATE : code ROUTINE : cm_cvt_cmd |
4218 +----------------------------------------------------------------------+
4219
4220
4221 PURPOSE : Convert AoC command
4222
4223 */
4224
4225 UBYTE cm_cvt_cmd(T_ACI_AT_CMD cmdId)
4226 {
4227 switch (cmdId)
4228 {
4229 case AT_CMD_CACM: return CM_AOC_ACM;
4230 case AT_CMD_CAMM: return CM_AOC_ACMMAX;
4231 case AT_CMD_CPUC: return CM_AOC_PUCT;
4232 default: return CM_AOC_UNKNOWN;
4233 }
4234 }
4235
4236
4237 /*
4238 +----------------------------------------------------------------------+
4239 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
4240 | STATE : code ROUTINE : cm_ok_aoc |
4241 +----------------------------------------------------------------------+
4242
4243
4244 PURPOSE : Setting AoC is successful.
4245
4246 */
4247
4248 void cm_ok_aoc(T_ACI_AT_CMD cmdId)
4249 {
4250 T_MFW_CM_AOC_CNF aoc_cnf;
4251
4252 aoc_cnf.requested_type = cm_cvt_cmd(cmdId);
4253 aoc_cnf.result = CM_AOC_CONF_OK;
4254 cm_signal(E_CM_AOC_CNF, &aoc_cnf);
4255 }
4256
4257
4258 /*
4259 +----------------------------------------------------------------------+
4260 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
4261 | STATE : code ROUTINE : cm_error_aoc |
4262 +----------------------------------------------------------------------+
4263
4264
4265 PURPOSE : Setting AoC is failure.
4266
4267 */
4268
4269 void cm_error_aoc(T_ACI_AT_CMD cmdId, T_ACI_CME_ERR reason)
4270 {
4271 T_MFW_CM_AOC_CNF aoc_cnf;
4272
4273 aoc_cnf.requested_type = cm_cvt_cmd(cmdId);
4274 aoc_cnf.result = CM_AOC_CONF_UNKNOWN;
4275
4276 if (reason EQ CME_ERR_SimPin2Req)
4277 aoc_cnf.result = CM_AOC_CONF_SIMPIN2REQ;
4278
4279 if (reason EQ CME_ERR_WrongPasswd)
4280 aoc_cnf.result = CM_AOC_CONF_WRONGPASSWD;
4281
4282 if (reason EQ CME_ERR_OpNotAllow)
4283 aoc_cnf.result = CM_AOC_CONF_OPNOTALLOW;
4284
4285 if (reason EQ CME_ERR_AcmResetNeeded)
4286 aoc_cnf.result = CM_AOC_CONF_ACMRESETNEEDED;
4287
4288 cm_signal(E_CM_AOC_CNF, &aoc_cnf);
4289 }
4290
4291
4292 /*
4293 +-----------------------------------------------------------------+
4294 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
4295 | STATE : code ROUTINE : rAT_PercentCTV |
4296 +-----------------------------------------------------------------+
4297
4298
4299 PURPOSE : manage timer in every second
4300
4301 */
4302
4303 void rAT_PercentCTV()
4304 {
4305 TRACE_FUNCTION("rAT_PercentCTV()");
4306 cm_signal(E_CM_TIMER_EVERY_SECOND, 0);
4307 }
4308
4309
4310 /*
4311 +-----------------------------------------------------------------+
4312 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
4313 | STATE : code ROUTINE : rAT_PlusCCCM |
4314 +-----------------------------------------------------------------+
4315
4316
4317 PURPOSE :
4318
4319 */
4320
4321 void rAT_PlusCCCM(LONG *ccm)
4322 {
4323 T_MFW_CM_AOC_INFO aoc_info;
4324 T_ACI_RPCT_VAL rpuct;
4325
4326 TRACE_FUNCTION("rAT_PlusCCCM()");
4327
4328 memset(&aoc_info, 0, sizeof(T_MFW_CM_AOC_INFO));
4329
4330 qAT_PlusCAMM(CMD_SRC_LCL, &aoc_info.acm_max);
4331 qAT_PlusCACM(CMD_SRC_LCL, &aoc_info.acm);
4332 aoc_info.ccm = *ccm;
4333 qAT_PercentCTV(CMD_SRC_LCL, &aoc_info.actual_call_timer);
4334 qAT_PercentRPCT(CMD_SRC_LCL, &rpuct);
4335 strncpy((char *)aoc_info.cur, (char *)rpuct.currency, MAX_CUR_LEN);
4336 aoc_info.requested_type = CM_AOC_CCM;
4337 aoc_info.eppu = rpuct.eppu;
4338 aoc_info.exp = rpuct.exp;
4339 aoc_info.sexp = rpuct.sexp;
4340
4341 cm_signal(E_CM_AOC, &aoc_info);
4342 }
4343
4344
4345 /*
4346 +----------------------------------------------------------------+
4347 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
4348 | STATE : code ROUTINE : cm_set_redial |
4349 +----------------------------------------------------------------+
4350
4351
4352 PURPOSE : Set redial mode (automatic/manual).
4353
4354 */
4355
4356 void cm_set_redial(UBYTE redial_mode)
4357 {
4358 // U8 version; // RAVI
4359 // Apr 14, 2005 REF: CRR 29991 xpradipg
4360 // local definition
4361 #ifdef FF_MMI_OPTIM
4362 T_MFW_CM_BLACKLIST_LIST black_list;
4363 #endif
4364
4365 TRACE_FUNCTION ("cm_set_redial()");
4366
4367 if (redial_mode == CM_REDIAL_BLACKLIST)
4368 {
4369 memset(&black_list, 0, sizeof(T_MFW_CM_BLACKLIST_LIST));
4370 // Apr 14, 2005 REF: CRR 29991 xpradipg
4371 // reset the file contents
4372 #ifdef FF_MMI_OPTIM
4373 if(flash_MMI_blackList_write((U8 *)&black_list, sizeof(T_MFW_CM_BLACKLIST_LIST),0) < 0)
4374 TRACE_FUNCTION(" Error writing into file");
4375 #endif
4376 return;
4377 }
4378
4379 if (redial_mode == CM_REDIAL_OFF
4380 || redial_mode == CM_REDIAL_AUTO
4381 || redial_mode == CM_REDIAL_MANU)
4382 {
4383 redial_stat = redial_mode;
4384
4385 /* write redialing mode to EEPROM */
4386
4387 FFS_flashData.redial_mode =redial_mode;
4388 flash_write();
4389
4390 }
4391 }
4392
4393
4394 /*
4395 +---------------------------------------------------------------------+
4396 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
4397 | STATE : code ROUTINE : cm_get_redial_mode |
4398 +---------------------------------------------------------------------+
4399
4400
4401 PURPOSE : Request the setting of redial mode (automatic/manual).
4402
4403 */
4404
4405 T_MFW cm_get_redial_mode(void)
4406 {
4407 return redial_stat;
4408 }
4409
4410
4411
4412
4413 /*
4414 +--------------------------------------------------------------------+
4415 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
4416 | STATE : code ROUTINE: cm_stop_redialTim |
4417 +--------------------------------------------------------------------+
4418
4419
4420 PURPOSE : Stop redialing time.
4421
4422 */
4423
4424 void cm_stop_redialTim(void)
4425 {
4426 if (!redial_count)
4427 timStop(redialTim1);
4428
4429 if (redial_count >= 1 AND redial_count <= 3)
4430 timStop(redialTim24);
4431
4432 if (redial_count >= 4 AND redial_count < MAX_REDIAL_ATTEMPT)
4433 timStop(redialTim5);
4434 redial_count = 0;
4435 rdl.left_attempts = 0;
4436
4437 /*
4438 reset the counter
4439 */
4440
4441 call_stat = MFW_CALL_FREE;
4442 call_type = MFW_CALL_FREE;
4443 cc_stat.type = MFW_CALL_FREE;
4444 }
4445
4446
4447 /*
4448 +--------------------------------------------------------------------+
4449 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
4450 | STATE : code ROUTINE: cm_redial_abort |
4451 +--------------------------------------------------------------------+
4452
4453
4454 PURPOSE : Stop redialing from MMI.
4455
4456 */
4457
4458 void cm_redial_abort(void)
4459 {
4460
4461 TRACE_FUNCTION ("cm_redial_abort()");
4462
4463 if (call_stat == REDIALING_CALL OR call_stat == OUTGOING_CALL)
4464 cm_stop_redialTim();
4465
4466 rdl.redial_mode = CM_REDIAL_ABORTED;
4467 cm_signal(E_CM_REDIAL, &rdl);
4468 }
4469
4470
4471 /*
4472 +---------------------------------------------------------------------+
4473 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
4474 | STATE : code ROUTINE: cm_autoredial_start |
4475 +---------------------------------------------------------------------+
4476
4477
4478 PURPOSE : start autoredial.
4479
4480 */
4481
4482 void cm_autoredial_start(void)
4483 {
4484 timStart(redialTim1);
4485 }
4486
4487
4488 /*
4489 +--------------------------------------------------------------------+
4490 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
4491 | STATE : code ROUTINE: cm_redial_timeout |
4492 +--------------------------------------------------------------------+
4493
4494
4495 PURPOSE : Call back from system clock for redialing time interval.
4496
4497 */
4498
4499 static int cm_redial_timeout(MfwEvt e, MfwTim *t)
4500 {
4501 CHAR number[MFW_NUM_LEN+MAX_LEN+1];
4502 int max_num_size = MFW_NUM_LEN+MAX_LEN+1;
4503
4504 TRACE_FUNCTION ("cm_redial_timeout()");
4505
4506 memset(number, 0, sizeof(number));
4507 mfwStrncpy(number, (CHAR *)cc_stat.prefix, max_num_size);
4508 max_num_size -= strlen((char *)cc_stat.prefix);
4509
4510 if ((cc_stat.ton EQ MFW_TON_INTERNATIONAL) AND (cc_stat.number[0] != '+'))
4511 {
4512 strcat(number, "+");
4513 max_num_size--;
4514 }
4515
4516 strncat(number, (CHAR *)cc_stat.number, max_num_size);
4517
4518 switch (redial_stat)
4519 {
4520 case CM_REDIAL_AUTO:
4521 if (sAT_Dn(CMD_SRC_LCL,
4522 (CHAR *)number,
4523 D_CLIR_OVRD_Default,
4524 D_CUG_CTRL_NotPresent,
4525 D_TOC_Voice) NEQ AT_EXCT)
4526 {
4527 TRACE_ERROR("sAT_Dn error");
4528 return 0;
4529 }
4530
4531 call_stat = OUTGOING_CALL;
4532
4533 cm_search_callId(CAL_STAT_Dial, &cc_stat.call_number);
4534 cc_stat.type = REDIALING_CALL;
4535
4536 rdl.redial_mode = CM_REDIAL_ATTEMPT;
4537 rdl.call_id = cc_stat.call_number;
4538 mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
4539 #ifdef NO_ASCIIZ
4540 rdl.name.len = cc_stat.name.len;
4541 memcpy(rdl.name.data,
4542 cc_stat.name.data,
4543 cc_stat.name.len);
4544 #else
4545 mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
4546 // strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr);
4547 #endif
4548 rdl.ton = cc_stat.ton;
4549 rdl.type = cc_stat.mode;
4550 redial_count++;
4551 rdl.left_attempts = MAX_REDIAL_ATTEMPT - redial_count;
4552 cm_signal(E_CM_REDIAL, &rdl);
4553 return 1;
4554
4555 case CM_REDIAL_MANU:
4556 rdl.redial_mode = CM_REDIAL_MANU;
4557 mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN);
4558 #ifdef NO_ASCIIZ
4559 rdl.name.len = cc_stat.name.len;
4560 memcpy(rdl.name.data,
4561 cc_stat.name.data,
4562 cc_stat.name.len);
4563 #else
4564 mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);
4565 #endif
4566 rdl.ton = cc_stat.ton;
4567 rdl.type = cc_stat.mode;
4568 rdl.left_attempts = MAX_REDIAL_ATTEMPT - redial_count;
4569
4570 cm_signal(E_CM_REDIAL, &rdl);
4571 return 1;
4572
4573 default:
4574 return 0;
4575 }
4576 }
4577
4578
4579 /*
4580 +--------------------------------------------------------------------+
4581 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
4582 | STATE : code ROUTINE: cm_redial |
4583 +--------------------------------------------------------------------+
4584
4585
4586 PURPOSE : Start the manual redialing.
4587
4588 */
4589
4590 void cm_redial()
4591 {
4592 char buf[80];
4593
4594 int max_buf_size = sizeof(buf);
4595
4596 TRACE_FUNCTION ("cm_redial()");
4597
4598 buf[0] = '\0';
4599
4600 mfwStrncpy(buf, (char *)cc_stat.prefix, max_buf_size);
4601 max_buf_size -= strlen((char *)cc_stat.prefix);
4602
4603 if ((cc_stat.ton EQ MFW_TON_INTERNATIONAL) AND (cc_stat.number[0] != '+'))
4604 {
4605 strcat(buf, "+");
4606 max_buf_size--;
4607 }
4608
4609 strncat(buf, (char *)cc_stat.number, max_buf_size);
4610
4611 if (sAT_Dn(CMD_SRC_LCL, buf, -1, -1, D_TOC_Voice) NEQ AT_EXCT)
4612 {
4613 TRACE_ERROR("sAT_Dn error");
4614 }
4615
4616 call_stat = OUTGOING_CALL;
4617 cc_stat.type = REDIALING_CALL;
4618 redial_count++;
4619 }
4620
4621
4622 /*
4623 +--------------------------------------------------------------------+
4624 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
4625 | STATE : code ROUTINE: cm_redial_get_count |
4626 +--------------------------------------------------------------------+
4627
4628
4629 PURPOSE : returns the counter of call attempt
4630
4631 */
4632 UBYTE cm_redial_get_count(void)
4633 {
4634 return redial_count;
4635 }
4636
4637
4638
4639 /*
4640 +--------------------------------------------------------------------+
4641 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
4642 | STATE : code ROUTINE: cm_cvt_call_status |
4643 +--------------------------------------------------------------------+
4644
4645
4646 PURPOSE : Convert the call status.
4647
4648 */
4649
4650 LOCAL T_MFW_CM_CALL_STAT cm_cvt_call_status( T_ACI_CAL_STAT stat )
4651 {
4652 switch ( stat )
4653 {
4654 case ( CAL_STAT_Held ): return CALL_HELD;
4655 case ( CAL_STAT_Active ): return CALL_ACTIVE;
4656 case ( CAL_STAT_Wait ): return CALL_WAIT;
4657 case ( CAL_STAT_Dial ): return CALL_DIAL;
4658 case (CAL_STAT_Alerting): return CALL_ALERT;
4659 case (CAL_STAT_DeactiveReq): return CALL_DEACTIVE;
4660 default: return NOT_PRESENT;
4661 }
4662 }
4663
4664 /*
4665 +--------------------------------------------------------------------+
4666 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
4667 | STATE : code ROUTINE: cm_cvt_call_status |
4668 +--------------------------------------------------------------------+
4669
4670
4671 PURPOSE : Request the call status.
4672
4673 */
4674
4675 T_MFW_CM_CALL_TYPE cm_cvt_call_mode( T_ACI_CAL_MODE type )
4676 {
4677 TRACE_EVENT_P1("cm_cnt_call_mode %d", type);
4678 switch ( type )
4679 {
4680 case ( CAL_MODE_Voice ): return VOICE_CALL;
4681 case ( CAL_MODE_Data ): return DATA_CALL;
4682 case ( CAL_MODE_Fax ): return FAX_CALL;
4683 case (CAL_MODE_VFD_Voice): return VFD_VOICE;
4684 case (CAL_MODE_VAD_Voice): return VAD_VOICE;
4685 case (CAL_MODE_VAF_Voice): return VAF_VOICE;
4686 case (CAL_MODE_VFD_Data): return VFD_DATA;
4687 case (CAL_MODE_VAD_Data): return VAD_DATA;
4688 case (CAL_MODE_VAF_Fax): return VAF_FAX;
4689 default: return NONE_TYPE;
4690 }
4691 }
4692
4693 T_MFW_CM_CALL_DIR cm_cvt_call_direction( T_ACI_CAL_TYPE type )
4694 {
4695 TRACE_EVENT_P1("cm_cvt_call_direction %d", type);
4696 switch ( type )
4697 {
4698 case ( CAL_TYPE_NotPresent): return MFW_CM_INV_DIR;
4699 case ( CAL_TYPE_MOC): return MFW_CM_MOC;
4700 case ( CAL_TYPE_MTC): return MFW_CM_MTC;
4701 default: return MFW_CM_INV_DIR;
4702 }
4703 }
4704
4705 /*
4706 +--------------------------------------------------------------------+
4707 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
4708 | STATE : code ROUTINE: cm_status |
4709 +--------------------------------------------------------------------+
4710
4711
4712 PURPOSE : Request the call status.
4713
4714 */
4715
4716 int cm_status(SHORT call_number, T_MFW_CM_STATUS *status, UBYTE num)
4717 {
4718 UBYTE cnt;
4719 int i;
4720 // Apr 06 2005 REF: CRR 29989 xpradipg
4721 // define and allocate memory
4722 #ifdef FF_MMI_OPTIM
4723 T_ACI_CAL_ENTR *call_tab;//[MAX_CALL_NR];
4724 call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
4725 if( NULL == call_tab)
4726 return 0;
4727 #endif
4728
4729
4730 cnt = 0;
4731 qAT_PercentCAL(CMD_SRC_LCL, call_tab);
4732
4733 if (call_number > 0)
4734 {
4735 for (i=0; i<MAX_CALL_NR; i++)
4736 {
4737 if (call_tab[i].index == call_number)
4738 {
4739 status[0].call_number = call_tab[i].index;
4740 status[0].stat = cm_cvt_call_status(call_tab[i].status);
4741 status[0].type = cm_cvt_call_mode(call_tab[i].calMode);
4742 status[0].mtpy = (T_MFW_MTPY_MEMBER)call_tab[i].mpty;
4743 status[0].call_direction = cm_cvt_call_direction(call_tab[i].calType);
4744
4745 if (call_tab[i].number != NULL)
4746 {
4747 mfwStrncpy((char *)status[0].number, call_tab[i].number, MFW_NUM_LEN);
4748 status[0].ton = phb_cvtTon(call_tab[i].type.ton);
4749 }
4750 else
4751 memset(status[0].number, '\0', MFW_NUM_LEN);
4752
4753 #ifdef NO_ASCIIZ
4754 status[0].name.len = call_tab[i].alpha.len;
4755 if (call_tab[i].alpha.len)
4756 memcpy(status[0].name.data,
4757 call_tab[i].alpha.data,
4758 call_tab[i].alpha.len);
4759 else //We'll also zero the string.
4760 memset(status[0].name.data, '\0', PHB_MAX_LEN);
4761 #else
4762 if (call_tab[i].alpha != NULL)
4763 mfwStrncpy((char *)status[0].name, call_tab[i].alpha, MFW_TAG_LEN);
4764 else
4765 memset(status[0].name, '\0', MFW_TAG_LEN);
4766 #endif
4767 cnt = 1;
4768 break;
4769 }
4770 }
4771 // Apr 06 2005 REF: CRR 29989 xpradipg
4772 // deallocate memory
4773 #ifdef FF_MMI_OPTIM
4774 if(call_tab)
4775 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
4776 #endif
4777 return cnt;
4778 }
4779
4780 if (!call_number)
4781 {
4782 for (i=0; i<MAX_CALL_NR; i++)
4783 {
4784 if ((call_tab[i].index EQ -1) OR cnt > num)
4785 break;
4786
4787 if (call_tab[i].status != CAL_STAT_NotPresent)
4788 {
4789 status[cnt].call_number = call_tab[i].index;
4790 status[cnt].stat = cm_cvt_call_status(call_tab[i].status);
4791 status[cnt].type = cm_cvt_call_mode(call_tab[i].calMode);
4792 status[cnt].mtpy = (T_MFW_MTPY_MEMBER)call_tab[i].mpty;
4793 if (call_tab[i].number != NULL)
4794 {
4795 mfwStrncpy((char *)status[cnt].number, call_tab[i].number, MFW_NUM_LEN);
4796 status[cnt].ton = phb_cvtTon(call_tab[i].type.ton);
4797 }
4798 else
4799 memset(status[cnt].number, '\0', MFW_NUM_LEN);
4800
4801 #ifdef NO_ASCIIZ
4802 status[cnt].name.len = call_tab[i].alpha.len;
4803 if (call_tab[i].alpha.len != 0)
4804 memcpy(status[cnt].name.data,
4805 call_tab[i].alpha.data,
4806 call_tab[i].alpha.len);
4807 else //We'll also zero the string.
4808 memset(status[cnt].name.data, '\0', PHB_MAX_LEN);
4809 #else
4810 if (call_tab[i].alpha != NULL)
4811 mfwStrncpy((char *)status[cnt].name, call_tab[i].alpha, MFW_TAG_LEN);
4812 else
4813 memset(status[cnt].name, '\0', MFW_TAG_LEN);
4814 #endif
4815 cnt++;
4816 }
4817 }
4818 // Apr 06 2005 REF: CRR 29989 xpradipg
4819 // deallocate memory
4820 #ifdef FF_MMI_OPTIM
4821 if(call_tab)
4822 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
4823 #endif
4824 return cnt;
4825 }
4826 // Apr 06 2005 REF: CRR 29989 xpradipg
4827 // deallocate memory
4828 #ifdef FF_MMI_OPTIM
4829 if(call_tab)
4830 mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR);
4831 #endif
4832 return 0;
4833 }
4834
4835
4836 /*
4837 +--------------------------------------------------------------------+
4838 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
4839 | STATE : code ROUTINE: cm_AT_CHLD |
4840 +--------------------------------------------------------------------+
4841
4842
4843 PURPOSE : Notify the CHLD command
4844
4845 */
4846
4847 void cm_AT_CHLD(T_ACI_CLOG *clog_cmd)
4848 {
4849 SHORT id;
4850 T_ACI_CAL_MODE call_mode;
4851 T_MFW_CM_STATUS status;
4852 char buf[80];
4853
4854 TRACE_EVENT("cm_AT_CHLD()");
4855
4856 /*SPR#1965 - DS - Removed setting of call_number to zero. Port of 1962
4857 *dis_connect.call_number = 0;
4858 */
4859 sprintf(buf, "dis_connect.call_number %d, cmd_hold %d, cId %d, srcId %d, mode %d, act %d",
4860 dis_connect.call_number, cmd_hold, clog_cmd->cId, clog_cmd->cmdPrm.sCHLD.srcId,
4861 clog_cmd->cmdPrm.sCHLD.mode, clog_cmd->cmdPrm.sCHLD.act);
4862 TRACE_EVENT(buf);
4863
4864 if ((clog_cmd->cmdPrm.sCHLD.act != CHLD_ACT_Retrieve) &&
4865 (clog_cmd->cmdPrm.sCHLD.act != CHLD_ACT_RetrieveMpty))
4866 {
4867 /*SPR#1962 - DS - Set call_number to call Id returned from ACI */
4868 TRACE_EVENT("Set dis_connect.call_number to clog_cmd->cId");
4869 dis_connect.call_number = clog_cmd->cId;
4870 }
4871 else
4872 {
4873 dis_connect.call_number = -1;
4874 }
4875 if (clog_cmd->cmdPrm.sCHLD.srcId == CMD_SRC_LCL)
4876 {
4877 switch(clog_cmd->cmdPrm.sCHLD.mode)
4878 {
4879 case CHLD_MOD_RelHldOrUdub:
4880
4881 if (cm_search_callId(CAL_STAT_DeactiveReq, &id) == CM_OK)
4882 {
4883 TRACE_FUNCTION("CAL_STAT_DeactiveReq - 0SEND");
4884 if ( cmd_hold EQ MFW_CM_1_SEND )
4885 {
4886 TRACE_FUNCTION("cmd_hold EQ MFW_CM_1_SEND");
4887 cm_status(id, &status, 1);
4888 if (status.mtpy EQ MFW_MTPY_MEMBER)
4889 dis_connect.call_number = 0;
4890 else
4891 dis_connect.call_number = id;
4892 }
4893 }
4894
4895 break;
4896
4897 case CHLD_MOD_RelActAndAcpt:
4898
4899 // MMI-SPR 13873 xkundadu
4900 // Handling of 1+SEND - Releases all active calls (if any exist) and
4901 // accepts the other (held or waiting) call.
4902
4903 if( (cm_search_callId(CAL_STAT_DeactiveReq, &id) == CM_OK) OR
4904 (cm_search_callId(CAL_STAT_Active, &id) == CM_OK))
4905 {
4906 // If there is an active call/active call whose disconnection
4907 // is initiated, store the index of that call.
4908 dis_connect.call_number = id;
4909 if(bIsMultpty == TRUE)
4910 {
4911 // Call is in multiparty
4912 // 1SEND for multiparty will disconnect all the active calls
4913 // To clear all calls assign the dis_connect.call_number to
4914 // zero
4915 dis_connect.call_number = 0;
4916 bIsMultpty = FALSE;
4917 }
4918 }
4919 else
4920 {
4921 // There is no active calls/active calls whose disconnection is
4922 // iniated existing
4923 dis_connect.call_number = -1;
4924 }
4925 if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)
4926 {
4927 // Waiting call is existing.
4928 // In the function cm_result_cmd(), value of cmd.call_number
4929 // is used to determine whether to call cm_connect() or not
4930 cmd.call_number=0;
4931 }
4932 cmd_hold = MFW_CM_1_SEND;
4933 break;
4934
4935 case CHLD_MOD_HldActAndAcpt:
4936
4937 // MMI -SPR 13873 xkundadu
4938 // Handling of 2+SEND - Places all active calls (if any exist) on hold
4939 // and accepts the other (held or waiting) call.
4940
4941 switch (clog_cmd->cmdPrm.sCHLD.act)
4942 {
4943
4944 case CHLD_ACT_Accept:
4945 // Accept the incoming call
4946 cmd_hold = MFW_CM_MT_ACCEPT;
4947 break;
4948
4949 case CHLD_ACT_Hold:
4950 // Getting the id of the call which has been put on hold by ACI
4951 cmd.command = CM_HOLD;
4952 if (cm_search_callId(CAL_STAT_Held, &id) == CM_OK)
4953 {
4954 cmd.call_number = id;
4955 }
4956 else
4957 {
4958 cmd.call_number = -1;
4959 }
4960 break;
4961
4962 case CHLD_ACT_Swap:
4963 // Swap the call
4964 cmd.command = CM_SWAP;
4965 break;
4966
4967 case CHLD_ACT_Retrieve:
4968 // Getting the id of the call which has been made active by ACI
4969 cmd.command = CM_RETRIEVE;
4970 if (cm_search_callId(CAL_STAT_Active, &id) == CM_OK)
4971 {
4972 cmd.call_number = id;
4973 }
4974 else
4975 {
4976 cmd.call_number = -1;
4977 }
4978 break;
4979 case CHLD_ACT_HoldMpty:
4980 // Put the calls on HOLD
4981 cmd.command = CM_HOLD_MULTIPARTY;
4982 break;
4983
4984 case CHLD_ACT_RetrieveMpty:
4985 // Retrieve the held calls to active
4986 cmd.command = CM_RETRIEVE_MULTIPARTY;
4987 break;
4988
4989 case CHLD_ACT_SwapMpty:
4990 // Swap muliparty calls
4991 cmd.command = CM_SWAP_MULTIPARTY;
4992 break;
4993
4994 default:
4995 cmd.command = CM_COMMAND_UNKNOWN;
4996 break;
4997
4998 }
4999 break;
5000 case CHLD_MOD_RelActSpec:
5001 dis_connect.call_number = (SHORT)atoi(clog_cmd->cmdPrm.sCHLD.call);
5002 break;
5003
5004 default:
5005 break;
5006 }
5007 }
5008
5009 // Aug 23, 2004 REF: CRR 22222 xkundadu
5010 // Bug: Runaway Call Waiting Tone.
5011 // Fix: Handle the AT-Command source id CMD_SRC_ATI_2 also for call control
5012 // callback functions.Include source Id CMD_SRC_ATI_2 also for checking.
5013
5014 //Nov 02, 2005 DR OMAPS00052132 xdeepadh
5015 //The usage of ATI enum is put under the flag FF_ATI
5016 #ifdef FF_ATI
5017 if ((clog_cmd->cmdPrm.sCHLD.srcId == CMD_SRC_ATI_1) //NM Berlin UK integration
5018 OR (clog_cmd->cmdPrm.sCHLD.srcId == CMD_SRC_ATI_2)) // Added for MMI-SPR 22222 FIX
5019 {
5020 switch(clog_cmd->cmdPrm.sCHLD.mode)
5021 {
5022 case CHLD_MOD_RelHldOrUdub:
5023 if (clog_cmd->cmdPrm.sCHLD.act == CHLD_ACT_Release)
5024 dis_connect.call_number = clog_cmd->cId;
5025 cmd_hold = MFW_CM_TERMINATED;
5026 break;
5027 case CHLD_MOD_RelActAndAcpt:
5028 switch (clog_cmd->cmdPrm.sCHLD.act)
5029 {
5030 case CHLD_ACT_Release:
5031 dis_connect.call_number = clog_cmd->cId;
5032 break;
5033 case CHLD_ACT_Accept:
5034 if (cm_search_callId(CAL_STAT_DeactiveReq, &id) == CM_OK)
5035 dis_connect.call_number = id;
5036 else if (cm_search_callId(CAL_STAT_Active, &id) == CM_OK)
5037 {
5038 call_mode = cm_search_callMode(id);
5039 if (call_mode EQ CAL_MODE_Data
5040 OR call_mode EQ CAL_MODE_Fax)
5041 dis_connect.call_number = id;
5042 }
5043 if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)
5044 cc_id = id;
5045 break;
5046 case CHLD_ACT_Retrieve:
5047 if (cm_search_callId(CAL_STAT_Held, &id) == CM_OK)
5048 {
5049 cmd.command = CM_RETRIEVE;
5050 cmd.call_number = id;
5051 }
5052 if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)
5053 cc_id = id;
5054 break;
5055 }
5056 cmd_hold = MFW_CM_1_SEND;
5057 break;
5058 case CHLD_MOD_RelActSpec:
5059 dis_connect.call_number = clog_cmd->cId;
5060 if (dis_connect.call_number)
5061 cmd_hold = MFW_CM_TERMINATED;
5062 else
5063 cmd_hold = MFW_CM_MPTY_TERMINATED;
5064 break;
5065 case CHLD_MOD_HldActAndAcpt:
5066 switch (clog_cmd->cmdPrm.sCHLD.act)
5067 {
5068 case CHLD_ACT_Accept:
5069 cmd_hold = MFW_CM_MT_ACCEPT;
5070 break;
5071 case CHLD_ACT_Hold:
5072 cmd.command = CM_HOLD;
5073 if (cm_search_callId(CAL_STAT_Held, &id) == CM_OK)
5074 cmd.call_number = id;
5075 else
5076 cmd.call_number = -1;
5077 break;
5078 case CHLD_ACT_Swap:
5079 cmd.command = CM_SWAP;
5080 break;
5081 case CHLD_ACT_Retrieve:
5082 cmd.command = CM_RETRIEVE;
5083 if (cm_search_callId(CAL_STAT_Active, &id) == CM_OK)
5084 cmd.call_number = id;
5085 else
5086 cmd.call_number = -1;
5087 break;
5088 case CHLD_ACT_SwapMpty:
5089 cmd.command = CM_SWAP_MULTIPARTY;
5090 break;
5091 case CHLD_ACT_HoldMpty:
5092 cmd.command = CM_HOLD_MULTIPARTY;
5093 break;
5094 case CHLD_ACT_RetrieveMpty:
5095 cmd.command = CM_RETRIEVE_MULTIPARTY;
5096 break;
5097 default:
5098 cmd.command = CM_COMMAND_UNKNOWN;
5099 break;
5100 }
5101 break;
5102 case CHLD_MOD_HldActExc:
5103 if (clog_cmd->cmdPrm.sCHLD.act == CHLD_ACT_SplitMpty)
5104 cmd.command = CM_SPLIT_MULTIPARTY;
5105 else
5106 cmd.command = CM_COMMAND_UNKNOWN;
5107 break;
5108 case CHLD_MOD_AddHld:
5109 if (clog_cmd->cmdPrm.sCHLD.act == CHLD_ACT_BuildMpty)
5110 cmd.command = CM_RETRIEVE_MULTIPARTY;
5111 else
5112 cmd.command = CM_COMMAND_UNKNOWN;
5113 break;
5114 case CHLD_MOD_Ect:
5115 cmd.command = CM_ETC;
5116 break;
5117 case CHLD_MOD_Ccbs:
5118 TRACE_EVENT("CHLD_MOD_Ccbs");
5119 cmd.command = CM_CCBS;
5120 break;
5121 case CHLD_MOD_HldActDial:
5122 cmd_hold = MFW_CM_HOLD_AND_DIAL;
5123 cmd.command = CM_HOLD;
5124 break;
5125 default:
5126 break;
5127 }
5128 }
5129 #endif //FF_ATI
5130 }
5131
5132
5133 /*
5134 +--------------------------------------------------------------------+
5135 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5136 | STATE : code ROUTINE: cm_AT_D |
5137 +--------------------------------------------------------------------+
5138
5139
5140 PURPOSE : Notify the outgoing call command.
5141
5142 */
5143
5144 void cm_AT_D(T_ACI_CLOG *cmd)
5145 {
5146 SHORT index;
5147 T_MFW_PHB_ENTRY entry;
5148 T_MFW_CM_CALL_STAT stat;
5149 UBYTE ton;
5150 UBYTE mode;
5151 T_MFW_PHB_TEXT findText;
5152
5153 TRACE_FUNCTION("cm_at_d()");
5154 #ifdef NO_ASCIIZ
5155 entry.name.len = 0;
5156 #else
5157 memset (entry.name, '\0', MAX_LEN);
5158 #endif
5159 memset (entry.number, '\0', MAX_LEN);
5160 entry.index = 0;
5161 entry.npi = 0;
5162 entry.ton = 0;
5163 entries.entry = &entry;
5164
5165 if (cmd->cmdPrm.sD.srcId == CMD_SRC_LCL)
5166 {
5167 out_call.call_id = cmd->cId;
5168 mfwStrncpy((char *)out_call.number, cmd->cmdPrm.sD.number, MFW_NUM_LEN);
5169 if (cc_stat.type == OUTGOING_CALL)
5170 {
5171 mfwStrncpy((char *)cc_stat.number, cmd->cmdPrm.sD.number, MFW_NUM_LEN);
5172 #ifdef NO_ASCIIZ
5173 cc_stat.name.len = 0;
5174 out_call.name.len = 0;
5175 #else
5176 cc_stat.name[0] = '\0';
5177 out_call.name[0] = '\0';
5178 #endif
5179 if (cm_search_callStat(cmd->cId, &stat, &ton, &mode) == CM_OK)
5180 {
5181 out_call.ton = ton;
5182 out_call.type = mode;
5183 cc_stat.ton = ton;
5184 cc_stat.mode = (T_MFW_CM_CALL_TYPE)mode;
5185 }
5186
5187 #ifdef NO_ASCIIZ
5188 mfwStrncpy((char *)findText.data, cmd->cmdPrm.sD.number, PHB_MAX_LEN);
5189 findText.len = strlen(cmd->cmdPrm.sD.number);
5190 if (phb_find_entries (PHB_ADN,
5191 &index,
5192 MFW_PHB_NUMBER,
5193 1,
5194 &findText,
5195 &entries) EQ MFW_PHB_OK)
5196 {
5197 if (entries.num_entries)
5198 {
5199 cc_stat.name.len = entries.entry[0].name.len;
5200 memcpy(cc_stat.name.data,
5201 entries.entry[0].name.data,
5202 entries.entry[0].name.len);
5203
5204 out_call.name.len = entries.entry[0].name.len;
5205 memcpy(out_call.name.data,
5206 entries.entry[0].name.data,
5207 entries.entry[0].name.len);
5208 }
5209 }
5210 #else
5211 if (phb_find_entries (PHB_ADN,
5212 &index,
5213 MFW_PHB_NUMBER,
5214 1,
5215 cmd->cmdPrm.sD.number,
5216 (T_MFW_PHB_LIST *)&entries) EQ MFW_PHB_OK)
5217 {
5218 if (entries.num_entries)
5219 {
5220 mfwStrncpy((char *)cc_stat.name, (char *)entries.entry[0].name, MFW_TAG_LEN);
5221 mfwStrncpy((char *)out_call.name, (char *)entries.entry[0].name, PHB_MAX_LEN);
5222 }
5223 }
5224 #endif
5225 }
5226
5227 if (cc_stat.type == REDIALING_CALL)
5228 {
5229 #ifdef NO_ASCIIZ
5230 out_call.name.len = cc_stat.name.len;
5231 memcpy(out_call.name.data,
5232 cc_stat.name.data,
5233 cc_stat.name.len);
5234 #else
5235 mfwStrncpy((char *)out_call.name, (char *)cc_stat.name, MFW_TAG_LEN);
5236 #endif
5237 out_call.ton = cc_stat.ton;
5238 out_call.type = cc_stat.mode;
5239 }
5240 cm_signal(E_CM_MO_RES, &out_call);
5241 }
5242 else if (cmd->cmdPrm.sD.srcId < CMD_SRC_MAX)
5243 {
5244 out_call.call_id = cmd->cId;
5245 mfwStrncpy((char *)out_call.number, (char *)cmd->cmdPrm.sD.number, MFW_NUM_LEN);
5246 #ifdef NO_ASCIIZ
5247 out_call.name.len = 0;
5248 #else
5249 out_call.name[0] = '\0';
5250 #endif
5251 if (cm_search_callStat(cmd->cId, &stat, &ton, &mode) == CM_OK)
5252 {
5253 out_call.ton = ton;
5254 out_call.type = mode;
5255 }
5256
5257 #ifdef NO_ASCIIZ
5258 mfwStrncpy((char *)findText.data, cmd->cmdPrm.sD.number, PHB_MAX_LEN);
5259 findText.len = strlen(cmd->cmdPrm.sD.number);
5260 if (phb_find_entries (PHB_ADN,
5261 &index,
5262 MFW_PHB_NUMBER,
5263 1,
5264 &findText,
5265 &entries) EQ MFW_PHB_OK)
5266 {
5267 if (entries.num_entries)
5268 {
5269 out_call.name.len = entries.entry[0].name.len;
5270 memcpy(out_call.name.data,
5271 entries.entry[0].name.data,
5272 entries.entry[0].name.len);
5273 }
5274 }
5275 #else
5276 if (phb_find_entries (PHB_ADN,
5277 &index,
5278 MFW_PHB_NUMBER,
5279 1,
5280 cmd->cmdPrm.sD.number,
5281 (T_MFW_PHB_LIST *)&entries) EQ MFW_PHB_OK)
5282 {
5283 if (entries.num_entries)
5284 {
5285 mfwStrncpy((char *)out_call.name, (char *)entries.entry[0].name, MFW_TAG_LEN);
5286 }
5287 }
5288 #endif
5289 cm_signal(E_CM_MO_RES, &out_call);
5290 }
5291 }
5292
5293
5294 /*
5295 +--------------------------------------------------------------------+
5296 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5297 | STATE : code ROUTINE: cm_cvtCPItype |
5298 +--------------------------------------------------------------------+
5299
5300
5301 PURPOSE : Convert the type of
5302
5303 */
5304
5305 T_MFW_CPI_TYPE cm_cvtCPItype(T_ACI_CPI_MSG msg)
5306 {
5307 switch (msg)
5308 {
5309 case CPI_MSG_Setup: return CPI_TYPE_SETUP;
5310 case CPI_MSG_Disc: return CPI_TYPE_DISC;
5311 case CPI_MSG_Alert: return CPI_TYPE_ALERT;
5312 case CPI_MSG_Proc: return CPI_TYPE_PROC;
5313 case CPI_MSG_Sync: return CPI_TYPE_SYNC;
5314 case CPI_MSG_Conn: return CPI_TYPE_CONN;
5315 /* CQ11676 Added new messages types in CPi indication. 17-02-04 MZ */
5316 #ifndef FF_2TO1_PS
5317 case CPI_MSG_Rls: return CPI_TYPE_RELEASE;
5318 case CPI_MSG_Rjct: return CPI_TYPE_REJECT;
5319 #endif
5320 default: return CPI_TYPE_UNKNOWN;
5321 }
5322 }
5323
5324
5325 /*
5326 +--------------------------------------------------------------------+
5327 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5328 | STATE : code ROUTINE: cm_cvtIBT |
5329 +--------------------------------------------------------------------+
5330
5331
5332 PURPOSE : Convert in-band tones indication
5333
5334 */
5335
5336 T_MFW_CPI_IBT cm_cvtIBT(T_ACI_CPI_IBT ibt)
5337 {
5338 switch (ibt)
5339 {
5340 case CPI_IBT_False: return CPI_IBT_FALSE;
5341 case CPI_IBT_True: return CPI_IBT_TRUE;
5342 default: return CPI_IBT_UNKNOWN;
5343 }
5344 }
5345
5346
5347 /*
5348 +--------------------------------------------------------------------+
5349 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5350 | STATE : code ROUTINE: cm_cvtTCH |
5351 +--------------------------------------------------------------------+
5352
5353
5354 PURPOSE : Convert traffic channel indication
5355
5356 */
5357
5358 T_MFW_CPI_TCH cm_cvtTCH(T_ACI_CPI_TCH tch)
5359 {
5360 switch (tch)
5361 {
5362 case CPI_TCH_False: return CPI_TCH_FALSE;
5363 case CPI_TCH_True: return CPI_TCH_TRUE;
5364 default: return CPI_TCH_UNKNOWN;
5365 }
5366 }
5367
5368
5369 /*
5370 +--------------------------------------------------------------------+
5371 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5372 | STATE : code ROUTINE: rAT_PercentCPI |
5373 +--------------------------------------------------------------------+
5374
5375
5376 PURPOSE : Call Progress Information
5377
5378 */
5379 // ADDED BY RAVI - FOR ACI CHANGES - 5-10-2005
5380 #if (defined(FF_2TO1_PS) && BOARD != 61)
5381 void rAT_PercentCPI(SHORT cId,
5382 T_ACI_CPI_MSG msgType,
5383 T_ACI_CPI_IBT ibt,
5384 T_ACI_CPI_TCH tch)
5385
5386 {
5387 cm_cpi.call_number = cId;
5388 cm_cpi.type = cm_cvtCPItype(msgType);
5389 cm_cpi.inband = cm_cvtIBT(ibt);
5390 cm_cpi.tch = cm_cvtTCH(tch);
5391 // cm_cpi.cause = CPI_CAUSE_MASK & cause; /* cq11676 Add cause information to the CPI indication 17-02-04 MZ */
5392 cm_signal(E_CM_CPI, &cm_cpi);
5393 }
5394 #else
5395 void rAT_PercentCPI(SHORT cId,
5396 T_ACI_CPI_MSG msgType,
5397 T_ACI_CPI_IBT ibt,
5398 T_ACI_CPI_TCH tch,
5399 USHORT cause ) /*cq11676 Add cause parameter for cpi indication 17-02-04 MZ */
5400 {
5401 cm_cpi.call_number = cId;
5402 cm_cpi.type = cm_cvtCPItype(msgType);
5403 cm_cpi.inband = cm_cvtIBT(ibt);
5404 cm_cpi.tch = cm_cvtTCH(tch);
5405 cm_cpi.cause = CPI_CAUSE_MASK & cause; /* cq11676 Add cause information to the CPI indication 17-02-04 MZ */
5406 cm_signal(E_CM_CPI, &cm_cpi);
5407 }
5408 #endif
5409 // END OF ADDITION - RAVI - 5-10-2005.
5410
5411 /*
5412 +--------------------------------------------------------------------+
5413 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5414 | STATE : code ROUTINE: cm_error_code |
5415 +--------------------------------------------------------------------+
5416
5417
5418 PURPOSE :
5419
5420 */
5421
5422 UBYTE cm_error_code(T_ACI_AT_CMD cmd)
5423 {
5424 ULONG err;
5425
5426 err = qAT_ErrDesc();
5427 switch (ACI_ERR_DESC_CLASS( err ))
5428 {
5429 case ACI_ERR_CLASS_Cme:
5430 break;
5431 case ACI_ERR_CLASS_Cms:
5432 break;
5433 case ACI_ERR_CLASS_Ceer:
5434 switch (ACI_ERR_DESC_NR( err ))
5435 {
5436 case CEER_ACM_Max: return CM_ACM_MAX;
5437 default: return CM_ERROR;
5438 }
5439 // break; // RAVI
5440 case ACI_ERR_CLASS_Ext:
5441 switch (ACI_ERR_DESC_NR( err ))
5442 {
5443 case EXT_ERR_FdnCheck: return CM_CFDN_ERR;
5444 case EXT_ERR_BdnCheck: return CM_CBDN_ERR;
5445 case EXT_ERR_OneCallOnHold: return CM_2CALLS_ALREADY_ERR;
5446 //xvilliva 21421 - Handling err code returned by ACI.
5447 #ifndef FF_2TO1_PS
5448 case EXT_ERR_AlsLock: return CM_ALS_ERR;
5449 #endif
5450 default: return CM_ERROR;
5451 }
5452 // break; // RAVI
5453 default:
5454 break;
5455 }
5456 return CM_ERROR;
5457 }
5458
5459 /*
5460 +--------------------------------------------------------------------+
5461 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
5462 | STATE : code ROUTINE : cm_bc_parameter |
5463 +--------------------------------------------------------------------+
5464
5465
5466 PURPOSE : Notice bearer service parameter
5467
5468 */
5469
5470 void cm_bc_parameter(T_ACI_CRING_TYP type)
5471 {
5472 TRACE_FUNCTION("cm_cvt_cringType()");
5473
5474 switch (type)
5475 {
5476 case CRING_TYP_Voice:
5477 break;
5478 case CRING_TYP_Fax:
5479 in_call.bc1.conn_elem = Transparent;
5480 break;
5481 case CRING_TYP_Sync:
5482 in_call.bc1.bearer_serv = Synch;
5483 in_call.bc1.conn_elem = Transparent;
5484 break;
5485 case CRING_TYP_Async:
5486 in_call.bc1.bearer_serv = Asynch;
5487 in_call.bc1.conn_elem = Transparent;
5488 break;
5489 case CRING_TYP_RelSync:
5490 in_call.bc1.bearer_serv = Synch;
5491 in_call.bc1.conn_elem = NonTransparent;
5492 break;
5493 case CRING_TYP_RelAsync:
5494 in_call.bc1.bearer_serv = Asynch;
5495 in_call.bc1.conn_elem = NonTransparent;
5496 break;
5497 default:
5498 break;
5499 }
5500 }
5501
5502 /*
5503 +--------------------------------------------------------------------+
5504 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
5505 | STATE : code ROUTINE : cm_build_callType |
5506 +--------------------------------------------------------------------+
5507
5508
5509 PURPOSE :
5510
5511 */
5512
5513 void cm_build_callType(T_ACI_CRING_TYP type1, T_ACI_CRING_TYP type2)
5514 {
5515 if (type1 EQ CRING_TYP_Voice)
5516 {
5517 switch (type2)
5518 {
5519 case CRING_TYP_Sync:
5520 case CRING_TYP_Async:
5521 case CRING_TYP_RelSync:
5522 case CRING_TYP_RelAsync:
5523 in_call.type = VAD_VOICE;
5524 return;
5525 case CRING_TYP_Fax:
5526 in_call.type = VAF_VOICE;
5527 return;
5528 default:
5529 break;
5530 }
5531 }
5532 if (type2 EQ CRING_TYP_Voice)
5533 {
5534 switch (type1)
5535 {
5536 case CRING_TYP_Sync:
5537 case CRING_TYP_Async:
5538 case CRING_TYP_RelSync:
5539 case CRING_TYP_RelAsync:
5540 in_call.type = VAD_DATA;
5541 return;
5542 case CRING_TYP_Fax:
5543 in_call.type = VAF_FAX;
5544 return;
5545 default:
5546 break;
5547 }
5548 }
5549 in_call.type = NONE_TYPE;
5550 }
5551
5552 /*
5553 +--------------------------------------------------------------------+
5554 | PROJECT : MMI-Framework (8417) MODULE : MFW_CM |
5555 | STATE : code ROUTINE : cmCommand |
5556 +--------------------------------------------------------------------+
5557
5558 PURPOSE : handle mfw windows command
5559
5560 */
5561
5562 static int cmCommand (U32 cmd, void *h)
5563 {
5564 switch (cmd)
5565 {
5566 case MfwCmdDelete: /* delete me */
5567 if (!h)
5568 return 0;
5569 cm_delete(h);
5570 return 1;
5571 default:
5572 break;
5573 }
5574
5575 return 0;
5576 }
5577
5578 /*
5579 +--------------------------------------------------------------------+
5580 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5581 | STATE : code ROUTINE: cm_command_abort |
5582 +--------------------------------------------------------------------+
5583
5584
5585 PURPOSE :
5586
5587 */
5588
5589 T_MFW cm_command_abort(UBYTE command)
5590 {
5591 TRACE_FUNCTION ("cm_command()");
5592
5593 switch (command)
5594 {
5595 case CM_HOLD:
5596 case CM_SWAP:
5597 case CM_RETRIEVE:
5598 case CM_SWAP_MULTIPARTY:
5599 case CM_HOLD_MULTIPARTY:
5600 case CM_RETRIEVE_MULTIPARTY:
5601 case CM_BUILD_MULTIPARTY:
5602 case CM_SPLIT_MULTIPARTY:
5603 case CM_ETC:
5604 case CM_CCBS:
5605 sAT_Abort(CMD_SRC_LCL, AT_CMD_CHLD);
5606 break;
5607
5608 case CM_DTMF_ACTIVE:
5609 case CM_DTMF_INACTIVE:
5610 case CM_DTMF_AUTO:
5611 sAT_Abort(CMD_SRC_LCL, AT_CMD_VTS);
5612 break;
5613
5614 default:
5615 return FALSE;
5616 }
5617 return TRUE;
5618 }
5619
5620 /* Marcus: CCBS: 13/11/2002: Start */
5621 /*
5622 +--------------------------------------------------------------------+
5623 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5624 | STATE : code ROUTINE: cm_ccbs_delete_all |
5625 +--------------------------------------------------------------------+
5626
5627 PURPOSE : Delete all registered CCBS
5628
5629 Returns: T_MFW: CM_OK if successful, CM_ERROR if not
5630
5631 Arguments: None
5632 */
5633 T_MFW cm_ccbs_delete_all(void)
5634 {
5635 T_MFW res = CM_ERROR; // The value to be returned by this function
5636 T_ACI_RETURN aci_res; // The value returned by sAT_PercentCCBS
5637
5638 TRACE_FUNCTION("cm_ccbs_delete_all()");
5639
5640 if (ccbs_op == CM_CCBS_NONE)
5641 {
5642 TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
5643 /* No CCBS operation currently in progress */
5644 #ifndef CCBS_TEST
5645 aci_res = sAT_PercentCCBS(CMD_SRC_LCL, 0);
5646 #else
5647 aci_res = AT_EXCT;
5648 #endif
5649 if (aci_res == AT_EXCT)
5650 {
5651 TRACE_EVENT("sAT_PercentCCBS returned AT_EXCT");
5652 ccbs_op = CM_CCBS_DELETE_ALL;
5653 res = CM_OK;
5654 }
5655 else
5656 {
5657 TRACE_EVENT_P1("sAT_PercentCCBS returned %d", aci_res);
5658 }
5659 }
5660 else
5661 {
5662 TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
5663 }
5664
5665 return res;
5666 }
5667
5668 /*
5669 +--------------------------------------------------------------------+
5670 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5671 | STATE : code ROUTINE: cm_ccbs_delete |
5672 +--------------------------------------------------------------------+
5673
5674 PURPOSE : Delete a specific registered CCBS
5675
5676 Returns: T_MFW: CM_OK if successful, CM_ERROR if not
5677
5678 Arguments: SHORT idx: the index to the specific CCBS to be deleted
5679 */
5680 T_MFW cm_ccbs_delete(SHORT idx)
5681 {
5682 T_MFW res = CM_ERROR; // The value to be returned by this function
5683 T_ACI_RETURN aci_res; // The value returned by sAT_PercentCCBS
5684
5685 TRACE_FUNCTION("cm_ccbs_delete()");
5686 TRACE_EVENT_P1("deleting CCBS %d", idx);
5687
5688 if (ccbs_op == CM_CCBS_NONE)
5689 {
5690 TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
5691 /* No CCBS operation currently in progress */
5692 #ifndef CCBS_TEST
5693 aci_res = sAT_PercentCCBS(CMD_SRC_LCL, idx);
5694 #else
5695 aci_res = AT_EXCT;
5696 #endif
5697 if (aci_res == AT_EXCT)
5698 {
5699 TRACE_EVENT("sAT_PercentCCBS returned AT_EXCT");
5700 ccbs_op = CM_CCBS_DELETE;
5701 res = CM_OK;
5702 }
5703 else
5704 {
5705 TRACE_EVENT_P1("sAT_PercentCCBS returned %d", aci_res);
5706 }
5707 }
5708 else
5709 {
5710 TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
5711 }
5712
5713 return res;
5714 }
5715
5716 /*
5717 +--------------------------------------------------------------------+
5718 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5719 | STATE : code ROUTINE: cm_ccbs_list |
5720 +--------------------------------------------------------------------+
5721
5722 PURPOSE : Delete all registered CCBS
5723
5724 Returns: T_MFW: CM_OK if successful, CM_ERROR if not
5725
5726 Arguments: None
5727 */
5728 T_MFW cm_ccbs_list(void)
5729 {
5730 T_MFW res = CM_ERROR; // The value to be returned by this function
5731 T_ACI_RETURN aci_res; // The value returned by qAT_PercentCCBS
5732
5733 TRACE_FUNCTION("cm_ccbs_list()");
5734
5735 if (ccbs_op == CM_CCBS_NONE)
5736 {
5737 /* No CCBS operation currently in progress */
5738 TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
5739 #ifndef CCBS_TEST
5740 aci_res = qAT_PercentCCBS(CMD_SRC_LCL);
5741 #else
5742 aci_res = AT_EXCT;
5743 #endif
5744 if (aci_res == AT_EXCT)
5745 {
5746 TRACE_EVENT("qAT_PercentCCBS returned AT_EXCT");
5747 ccbs_op = CM_CCBS_LIST;
5748 res = CM_OK;
5749 }
5750 else
5751 {
5752 TRACE_EVENT_P1("qAT_PercentCCBS returned %d", aci_res);
5753 }
5754 }
5755 else
5756 {
5757 TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
5758 }
5759
5760 return res;
5761 }
5762
5763 /*
5764 +--------------------------------------------------------------------+
5765 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5766 | STATE : code ROUTINE: cm_ccbs_accept_registration |
5767 +--------------------------------------------------------------------+
5768
5769 PURPOSE : Accepts the CCBS registration being offered
5770
5771 Returns: T_MFW: CM_OK if successful, CM_ERROR if not
5772
5773 Arguments: None
5774 */
5775 T_MFW cm_ccbs_accept_registration(void)
5776 {
5777 T_MFW res = CM_ERROR; // The value to be returned by this function
5778 T_ACI_RETURN aci_res; // The value returned by sAT_PlusCHLD
5779
5780 TRACE_FUNCTION("cm_ccbs_accept_registration()");
5781
5782 if (ccbs_op == CM_CCBS_NONE)
5783 {
5784 /* No CCBS operation currently in progress */
5785 TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
5786 cm_set_cmd_status(CHLD_MOD_Ccbs, "");
5787 cmd_hold = MFW_CM_CCBS_REGISTER;
5788 #ifndef CCBS_TEST
5789 aci_res = sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_Ccbs, NULL);
5790 #else
5791 aci_res = AT_EXCT;
5792 #endif
5793 if (aci_res == AT_EXCT)
5794 {
5795 TRACE_EVENT("sAT_PlusCHLD returned AT_EXCT");
5796 ccbs_op = CM_CCBS_ACCEPT_REGISTRATION;
5797 res = CM_OK;
5798 }
5799 else
5800 {
5801 TRACE_EVENT_P1("sAT_PlusCHLD returned %d", aci_res);
5802 }
5803 }
5804 else
5805 {
5806 TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
5807 }
5808
5809 return res;
5810 }
5811
5812 /*
5813 +--------------------------------------------------------------------+
5814 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5815 | STATE : code ROUTINE: cm_ccbs_reject_registration |
5816 +--------------------------------------------------------------------+
5817
5818 PURPOSE : Rejects the CCBS registration being offered
5819
5820 Returns: T_MFW: CM_OK if successful, CM_ERROR if not
5821
5822 Arguments: None
5823 */
5824 T_MFW cm_ccbs_reject_registration(void)
5825 {
5826 T_MFW res = CM_ERROR; // The value to be returned by this function
5827 T_ACI_RETURN aci_res; // The value returned by sAT_H
5828
5829 TRACE_FUNCTION("cm_ccbs_reject_registration()");
5830
5831 if (ccbs_op == CM_CCBS_NONE)
5832 {
5833 /* No CCBS operation currently in progress */
5834 TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
5835 cmd_hold = MFW_CM_CCBS_REGISTER;
5836 #ifndef CCBS_TEST
5837 aci_res = sAT_H(CMD_SRC_LCL);
5838 #else
5839 aci_res = AT_EXCT;
5840 #endif
5841 if (aci_res == AT_EXCT)
5842 {
5843 TRACE_EVENT("sAT_H returned AT_EXCT");
5844 ccbs_op = CM_CCBS_REJECT_REGISTRATION;
5845 res = CM_OK;
5846 }
5847 else
5848 {
5849 TRACE_EVENT_P1("sAT_H returned %d", aci_res);
5850 }
5851 }
5852 else
5853 {
5854 TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
5855 }
5856
5857 return res;
5858 }
5859
5860 /*
5861 +--------------------------------------------------------------------+
5862 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5863 | STATE : code ROUTINE: cm_ccbs_accept_recall |
5864 +--------------------------------------------------------------------+
5865
5866 PURPOSE : Accepts the CCBS recall being offered
5867
5868 Returns: T_MFW: CM_OK if successful, CM_BLACKIST or CM_ERROR if not
5869
5870 Arguments: UBYTE *number - the number of the phone to call
5871 T_MFW_CM_CALL_TYPE type - the type of the call to be made
5872 */
5873 T_MFW cm_ccbs_accept_recall(UBYTE *number, T_MFW_CM_CALL_TYPE type)
5874 {
5875 T_MFW res = CM_ERROR; // The value to be returned by this function
5876 int search_res; // The value returned by cm_search_callId
5877 T_ACI_RETURN aci_res; // The value returned by sAT_PlusCHLD
5878 SHORT call_number;// The call identity of any held call
5879 UBYTE phone[MFW_NUM_LEN]; // Working copy of phone number
5880 // CHAR *rest; // Parameter for ss_decode // RAVI
5881 // T_KSD_SEQPARAM para; // Parameter for ss_decode // RAVI
5882 // T_MFW_SS_RETURN ss_res; // The value returned by ss_decode // RAVI
5883
5884 TRACE_FUNCTION("cm_ccbs_accept_recall()");
5885
5886 if (ccbs_op == CM_CCBS_NONE)
5887 {
5888 /* No CCBS operation currently in progress */
5889 TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
5890 /* Ensure the number given is an ASCIIZ string thet is not too long */
5891 mfwStrncpy((char *)phone, (char *)number, MFW_NUM_LEN);
5892 TRACE_EVENT_P1("ccbs nr: %s", phone);
5893
5894 /* Make sure that it is OK to call this number */
5895 if ((res = cm_check_mo_number(phone)) == CM_OK)
5896 {
5897 TRACE_EVENT("cm_check_mo_number returned CM_OK");
5898 /* Set up data as for mobile originated call */
5899 cm_set_call_mode(type);
5900 call_stat = OUTGOING_CALL;
5901 redial_count = 0;
5902 cc_stat.type = OUTGOING_CALL;
5903 currConnecting = 1;
5904
5905 if ((search_res = cm_search_callId(CAL_STAT_Held, &call_number)) == CM_OK)
5906 {
5907 TRACE_EVENT("Held call: CHLD_MOD_RelActAndAcpt");
5908 /* There is a held call: release active call and accept callback */
5909 cm_set_cmd_status(CHLD_MOD_RelActAndAcpt, "");
5910 #ifndef CCBS_TEST
5911 aci_res = sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActAndAcpt, NULL);
5912 #else
5913 aci_res = AT_EXCT;
5914 #endif
5915 }
5916 else
5917 {
5918 TRACE_EVENT("No held call: CHLD_MOD_HldActAndAcpt");
5919 /* There is no held call: hold any active call and accept callback */
5920 cm_set_cmd_status(CHLD_MOD_HldActAndAcpt, "");
5921 #ifndef CCBS_TEST
5922 aci_res = sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_HldActAndAcpt, NULL);
5923 #else
5924 aci_res = AT_EXCT;
5925 #endif
5926 }
5927
5928 cmd_hold = MFW_CM_CCBS_RECALL;
5929
5930 if (aci_res == AT_EXCT)
5931 {
5932 TRACE_EVENT("sAT_PlusCHLD returned AT_EXCT");
5933 ccbs_op = CM_CCBS_ACCEPT_RECALL;
5934 res = CM_OK;
5935 }
5936 else
5937 {
5938 /* The attempt to accept the callback failed */
5939 TRACE_EVENT_P1("sAT_PlusCHLD returned %d", aci_res);
5940 call_stat = MFW_CALL_FREE;
5941 }
5942 }
5943 else
5944 {
5945 /* It is not OK to call this number for some reason */
5946 TRACE_EVENT_P1("cm_check_mo_number returned %d", res);
5947 }
5948 }
5949 else
5950 {
5951 TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
5952 }
5953
5954 return res;
5955 }
5956
5957 /*
5958 +--------------------------------------------------------------------+
5959 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
5960 | STATE : code ROUTINE: cm_ccbs_reject_recall |
5961 +--------------------------------------------------------------------+
5962
5963 PURPOSE : Rejects the CCBS recall being offered
5964
5965 Returns: T_MFW: CM_OK if successful, CM_ERROR if not
5966
5967 Arguments: None
5968 */
5969 T_MFW cm_ccbs_reject_recall(void)
5970 {
5971 T_MFW res = CM_ERROR; // The value to be returned by this function
5972 T_ACI_RETURN aci_res; // The value returned by sAT_PlusCHLD
5973
5974 TRACE_FUNCTION("cm_ccbs_reject_recall()");
5975
5976 if (ccbs_op == CM_CCBS_NONE)
5977 {
5978 /* No CCBS operation currently in progress */
5979 TRACE_EVENT("ccbs_op == CM_CCBS_NONE");
5980 cm_set_cmd_status(CHLD_MOD_RelHldOrUdub, "");
5981 cmd_hold = MFW_CM_CCBS_RECALL;
5982
5983 #ifndef CCBS_TEST
5984 aci_res = sAT_H(CMD_SRC_LCL);
5985 #else
5986 aci_res = AT_CMPL;
5987 #endif
5988 if (aci_res == AT_CMPL)
5989 {
5990 TRACE_EVENT("sAT_H returned AT_CMPL");
5991 ccbs_op = CM_CCBS_REJECT_RECALL;
5992 res = CM_OK;
5993 }
5994 else
5995 {
5996 TRACE_EVENT_P1("sAT_H returned %d", aci_res);
5997 }
5998 }
5999 else
6000 {
6001 TRACE_EVENT_P1("ccbs_op is %d", ccbs_op);
6002 }
6003
6004 return res;
6005 }
6006
6007 /*
6008 +--------------------------------------------------------------------+
6009 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
6010 | STATE : code ROUTINE: cm_ccbs_ok |
6011 +--------------------------------------------------------------------+
6012
6013 PURPOSE : Called by rAT_OK for "OK" result code for %CCBS command
6014
6015 Returns: Nothing
6016
6017 Arguments: None
6018 */
6019 void cm_ccbs_ok(void)
6020 {
6021 TRACE_FUNCTION("cm_ccbs_ok()");
6022
6023 memset((void *)&ccbs_info, 0, sizeof(ccbs_info));
6024
6025 ccbs_info.operation = ccbs_op;
6026 ccbs_op = CM_CCBS_NONE;
6027 ccbs_info.type = CM_CCBS_OK;
6028
6029 TRACE_EVENT_P2("E_CM_CCBS: op = %d: type = %d",
6030 ccbs_info.operation, ccbs_info.type);
6031
6032 cm_signal(E_CM_CCBS, &ccbs_info);
6033 }
6034
6035 /*
6036 +--------------------------------------------------------------------+
6037 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
6038 | STATE : code ROUTINE: cm_ccbs_error |
6039 +--------------------------------------------------------------------+
6040
6041 PURPOSE : Called by rAT_PlusCME for "+CME error" result code for %CCBS command
6042
6043 Returns: Nothing
6044
6045 Arguments: None
6046 */
6047 void cm_ccbs_error(void)
6048 {
6049 TRACE_FUNCTION("cm_ccbs_error()");
6050
6051 memset((void *)&ccbs_info, 0, sizeof(ccbs_info));
6052
6053 ccbs_info.operation = ccbs_op;
6054 ccbs_op = CM_CCBS_NONE;
6055 ccbs_info.type = CM_CCBS_ERROR;
6056
6057 TRACE_EVENT_P2("E_CM_CCBS: op = %d: type = %d",
6058 ccbs_info.operation, ccbs_info.type);
6059
6060 cm_signal(E_CM_CCBS, &ccbs_info);
6061 }
6062
6063 /*
6064 +--------------------------------------------------------------------+
6065 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
6066 | STATE : code ROUTINE: rAT_PercentCCBS |
6067 +--------------------------------------------------------------------+
6068
6069 PURPOSE : Called by ACI for "%CCBS:" result code
6070
6071 Returns: Nothing
6072
6073 Arguments: T_ACI_CCBS_IND indct - type of %CCBS indication
6074 T_ACI_CCBS_STAT status - status of %CCBS indication
6075 T_ACI_CCBS_SET *setting - optiona parameters of %CCBS indication
6076 */
6077 void rAT_PercentCCBS( T_ACI_CCBS_IND indct,
6078 T_ACI_CCBS_STAT status,
6079 T_ACI_CCBS_SET *setting )
6080 {
6081 TRACE_FUNCTION("rAT_PercentCCBS()");
6082 TRACE_EVENT_P3("indct = %d: status = %d: setting = %p", indct, status, setting);
6083
6084 memset((void *)&ccbs_info, 0, sizeof(ccbs_info));
6085
6086 /* Fill in the fields of the E_CM_CCBS event structure */
6087 switch (indct)
6088 {
6089 case CCBS_IND_Possible:
6090 case CCBS_IND_Recall:
6091 case CCBS_IND_PossibilityTimedOut:
6092 case CCBS_IND_RecallTimedOut:
6093
6094 /* An asynchronous %CCBS, not in response to a %CCBS command */
6095 TRACE_EVENT("Unsolicited event");
6096 ccbs_info.operation = CM_CCBS_ASYNC;
6097 break;
6098
6099 default:
6100 TRACE_EVENT("Solicited event");
6101 ccbs_info.operation = ccbs_op;
6102 break;
6103 }
6104
6105 ccbs_info.type = CM_CCBS_INFO;
6106 ccbs_info.indct = indct;
6107 ccbs_info.status = status;
6108
6109 TRACE_EVENT_P2("E_CM_CCBS: op = %d: type = %d",
6110 ccbs_info.operation, ccbs_info.type);
6111 TRACE_EVENT_P2(" indct = %d: status = %d",
6112 ccbs_info.indct, ccbs_info.status);
6113
6114 if (setting == (T_ACI_CCBS_SET *) NULL)
6115 {
6116 /* No T_ACI_CCBS_SET structure given. Indicate in the idx field of ccbs_info */
6117 TRACE_EVENT("setting == NULL");
6118 ccbs_info.idx = 0;
6119 }
6120 else
6121 {
6122 /* T_ACI_CCBS_SET structure given. Fill in the remaining field of ccbs_info */
6123 TRACE_EVENT("setting != NULL");
6124 ccbs_info.idx = setting->idx;
6125 strncpy((char *) ccbs_info.number, (char *) setting->number, sizeof(ccbs_info.number)-1);
6126 ccbs_info.number[sizeof(ccbs_info.number)-1] = '\0';
6127 ccbs_info.ton = phb_cvtTon(setting->type.ton);
6128 ccbs_info.call_type = cm_callTyp_cvt(setting->class_type);
6129 strncpy((char *) ccbs_info.subaddr, (char *) setting->subaddr, sizeof(ccbs_info.subaddr)-1);
6130 ccbs_info.subaddr[sizeof(ccbs_info.subaddr)-1] = '\0';
6131 ccbs_info.alrtPtn = setting->alrtPtn;
6132 TRACE_EVENT_P3(" idx = %d: number = %s: ton = %d",
6133 ccbs_info.idx, ccbs_info.number, ccbs_info.ton);
6134 TRACE_EVENT_P3(" call_type = %d: subaddr = %s: alrtPtn = %d",
6135 ccbs_info.call_type, ccbs_info.subaddr, ccbs_info.alrtPtn);
6136 }
6137
6138 cm_signal(E_CM_CCBS, &ccbs_info);
6139 }
6140
6141 /* Marcus: CCBS: 13/11/2002: End */
6142
6143 /*
6144 +--------------------------------------------------------------------+
6145 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
6146 | STATE : code ROUTINE: cm_error_dial |
6147 +--------------------------------------------------------------------+
6148
6149
6150 PURPOSE : The call setup is not successful
6151
6152 */
6153
6154 void cm_error_dial(T_ACI_CME_ERR err)
6155 {
6156 TRACE_FUNCTION("cm_error_dial()");
6157
6158 switch (err)
6159 {
6160 case CME_ERR_OpNotAllow: /* the active call can not be hold */
6161 /* allow a new outgoing */
6162 call_stat = MFW_CALL_FREE;
6163 call_type = MFW_CALL_FREE;
6164 cmd.command = CM_HOLD;
6165 if (cm_search_callId(CAL_STAT_Active, &cmd.call_number) NEQ CM_OK)
6166 cmd.call_number = -1;
6167 cmd.result = NotPresent;
6168 cm_signal(E_CM_COMMAND, &cmd);
6169 break;
6170
6171 /*SPR#2235 - DS - If handset is powered-up without a SIM and an emergency
6172 *call is attempted, the UK networks will reject the call attempt. Send a signal to
6173 *the BMI to enable it to destroy the call and show an appropriate error message.
6174 *
6175 *The ACI calls rAT_PlusCME() - then rAT_PlusCME() calls this funct - for this SIM
6176 *failure but the ACI doesn't supply the callId. Without the callId, the MFW/BMI
6177 *cannot close down the call properly. The ACI interface will need to be changed
6178 *so that it supplies the callId (if there is an active call) when this failure occurs.
6179 */
6180 case CME_ERR_SimFail:
6181 /* allow a new outgoing */
6182 call_stat = MFW_CALL_FREE;
6183 call_type = MFW_CALL_FREE;
6184
6185 /*SPR#2235 - DS - Fake the callId. Workaround needed until the ACI interface is changed */
6186 cm_error_connect(1);
6187 break;
6188
6189 default:
6190 TRACE_EVENT_P1("Error code: %d. No signal sent.", err);
6191 break;
6192 }
6193 }
6194
6195 /*
6196 +--------------------------------------------------------------------+
6197 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
6198 | STATE : code ROUTINE: cm_data_connect |
6199 +--------------------------------------------------------------------+
6200
6201
6202 PURPOSE : Fax/Data connect
6203
6204 */
6205
6206 void cm_data_connect(SHORT callId)
6207 {
6208 SHORT call_number;
6209
6210 TRACE_FUNCTION("cm_data_connect()");
6211
6212 call_number = callId;
6213 cm_signal(E_CM_CONNECT, &call_number);
6214 }
6215
6216 /*
6217 +--------------------------------------------------------------------+
6218 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
6219 | STATE : code ROUTINE: cm_data_connect |
6220 +--------------------------------------------------------------------+
6221
6222
6223 PURPOSE : Fax/Data connect
6224
6225 */
6226
6227 void cm_wap_data_connected(void)
6228 {
6229 // SHORT call_number; // RAVI
6230
6231 TRACE_FUNCTION("cm_wap_data_connected()");
6232
6233 cm_signal(E_CM_WAP_CALL_CONNECTED, NULL);
6234 }
6235 /*
6236 +--------------------------------------------------------------------+
6237 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
6238 | STATE : code ROUTINE: cm_deflect_incoming_call |
6239 +--------------------------------------------------------------------+
6240
6241
6242 PURPOSE : try to deflect a call using AT command CTFR
6243
6244 */
6245 T_MFW cm_deflect_incoming_call(char* number)
6246 { T_ACI_RETURN result;
6247 T_ACI_TOA type;
6248 T_ACI_TOS subaddr_type;
6249
6250 type.ton = TON_Unknown;
6251 type.npi = NPI_Unknown;
6252
6253 subaddr_type.tos = TOS_NotPresent;
6254 subaddr_type.oe = OE_NotPresent;
6255
6256 result = sAT_PlusCTFR(CMD_SRC_LCL, number, &type, NULL, &subaddr_type);
6257
6258 if ((result == AT_BUSY) || (result == AT_FAIL))
6259 return FALSE;
6260 return TRUE;
6261
6262 }
6263 /*
6264 +--------------------------------------------------------------------+
6265 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
6266 | STATE : code ROUTINE: cm_ok_CTFR |
6267 +--------------------------------------------------------------------+
6268
6269
6270 PURPOSE : sends call deflect OK event to MMI
6271
6272 */
6273 void cm_ok_CTFR(void)
6274 { BOOL status = TRUE;
6275
6276 cm_signal(E_CM_CALL_DEFLECT_STATUS, &status);
6277
6278 }
6279 /*
6280 +--------------------------------------------------------------------+
6281 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
6282 | STATE : code ROUTINE: cm_error_CTFR |
6283 +--------------------------------------------------------------------+
6284
6285
6286 PURPOSE : Sends call deflect failed event to MMI
6287
6288 */
6289 void cm_error_CTFR(void)
6290 {
6291 BOOL status = FALSE;
6292
6293 cm_signal(E_CM_CALL_DEFLECT_STATUS, &status);
6294 }
6295 #ifdef CCBS_TEST
6296 /* Marcus: CCBS testing: 20/11/2002: Start */
6297 static void strlower(char *string)
6298 {
6299 while(*string)
6300 {
6301 *string = (char)tolower((int) *string);
6302 string++;
6303 }
6304 }
6305
6306 static BOOL getCmdId(char *token, T_ACI_AT_CMD *cmdId)
6307 {
6308 BOOL cmdIdOk = FALSE;
6309 TRACE_FUNCTION("getCmdId()");
6310 if (token)
6311 {
6312 strlower(token);
6313 TRACE_EVENT_P1("token: %s", token);
6314 if (strstr(token, "ccbs"))
6315 {
6316 *cmdId = AT_CMD_CCBS;
6317 cmdIdOk = TRUE;
6318 }
6319 else if (strstr(token, "chld"))
6320 {
6321 *cmdId = AT_CMD_CHLD;
6322 cmdIdOk = TRUE;
6323 }
6324 else if (strcmp("h", token) == 0)
6325 {
6326 *cmdId = AT_CMD_H;
6327 cmdIdOk = TRUE;
6328 }
6329 else if ((*cmdId = atoi(token)))
6330 {
6331 cmdIdOk = TRUE;
6332 }
6333 }
6334 else
6335 {
6336 TRACE_EVENT("No token");
6337 }
6338
6339 return cmdIdOk;
6340 }
6341 #endif
6342
6343 void rAT_PercentMMITEST(char *param)
6344 {
6345 char work[80];
6346 char *token; // Current token obtained from strtok
6347 TRACE_FUNCTION("rAT_PercentMMITEST()");
6348
6349 strncpy(work, param, sizeof(work)-1);
6350 work[sizeof(work)-1] = '\0';
6351
6352 if ((token = strtok(work, ",()")) != NULL)
6353 {
6354 #ifdef CCBS_TEST
6355 T_ACI_AT_CMD cmdId;
6356 strlower(token);
6357 TRACE_EVENT_P1("token: %s", token);
6358
6359 if (strcmp("ok", token) == 0)
6360 {
6361 TRACE_EVENT("OK");
6362 if ((token = strtok(NULL, ",()")) != NULL)
6363 {
6364 if (getCmdId(token, &cmdId) == TRUE)
6365 {
6366 TRACE_EVENT_P1("rAT_OK(cmdId = %d", cmdId);
6367 rAT_OK(cmdId);
6368 }
6369 else
6370 {
6371 TRACE_EVENT("Unknown cmdId");
6372 }
6373 }
6374 else
6375 {
6376 TRACE_EVENT("No cmdId token");
6377 }
6378 }
6379 else if (strcmp("error", token) == 0)
6380 {
6381 TRACE_EVENT("ERROR");
6382 if ((token = strtok(NULL, ",()")) != NULL)
6383 {
6384 if (getCmdId(token, &cmdId) == TRUE)
6385 {
6386 T_ACI_CME_ERR err;
6387 if ((token = strtok(NULL, ",()")) != NULL)
6388 {
6389 err = atoi(token);
6390 rAT_PlusCME(cmdId, err);
6391 }
6392 else
6393 {
6394 TRACE_EVENT("No err token");
6395 }
6396 }
6397 }
6398 else
6399 {
6400 TRACE_EVENT("No cmdId token");
6401 }
6402 }
6403 else if (strcmp("info", token) == 0)
6404 {
6405 T_ACI_CCBS_IND indct = CCBS_IND_NotPresent;
6406 T_ACI_CCBS_STAT status = CCBS_STAT_NotPresent;
6407 T_ACI_CCBS_SET setting, *pSetting = NULL;
6408 TRACE_EVENT("INFO");
6409 if ((token = strtok(NULL, ",()")) != NULL)
6410 {
6411 strlower(token);
6412 TRACE_EVENT_P1("token: %s", token);
6413 if (strstr(token, "notpresent"))
6414 indct = CCBS_IND_NotPresent;
6415 else if (strstr(token, "possibility"))
6416 indct = CCBS_IND_PossibilityTimedOut;
6417 else if (strstr(token, "possible"))
6418 indct = CCBS_IND_Possible;
6419 else if (strstr(token, "registered"))
6420 indct = CCBS_IND_Registered;
6421 else if (strstr(token, "recallt"))
6422 indct = CCBS_IND_RecallTimedOut;
6423 else if (strstr(token, "recall"))
6424 indct = CCBS_IND_Recall;
6425 else if (strstr(token, "irgt"))
6426 indct = CCBS_IND_IrgtResult;
6427 }
6428
6429 if ((token = strtok(NULL, ",()")) != NULL)
6430 {
6431 strlower(token);
6432 TRACE_EVENT_P1("token: %s", token);
6433 if (strstr(token, "notpresent"))
6434 status = CCBS_STAT_NotPresent;
6435 else if (strstr(token, "notprov"))
6436 status = CCBS_STAT_NotProvisioned;
6437 else if (strstr(token, "prov"))
6438 status = CCBS_STAT_Provisioned;
6439 else if (strstr(token, "active"))
6440 status = CCBS_STAT_Active;
6441 }
6442
6443 setting.idx = 0;
6444 if ((token = strtok(NULL, ",()")) != NULL)
6445 {
6446 TRACE_EVENT_P1("token: %s", token);
6447 setting.idx = atoi(token);
6448 }
6449
6450 if (setting.idx != 0)
6451 {
6452 pSetting = &setting;
6453 strcpy(setting.number, "01317180538");
6454 setting.type.ton = TON_National;
6455 setting.type.npi = NPI_IsdnTelephony;
6456 setting.subaddr[0] = '\0';
6457 setting.satype.tos = TOS_NotPresent;
6458 setting.satype.oe = OE_NotPresent;
6459 setting.class_type = CLASS_Vce;
6460 setting.alrtPtn = ALPT_Level_0;
6461
6462 if ((token = strtok(NULL, ",()")) != NULL)
6463 {
6464 TRACE_EVENT_P1("token: %s", token);
6465 strncpy(setting.number, token, sizeof(setting.number)-1);
6466 setting.number[sizeof(setting.number)-1] = '\0';
6467 }
6468
6469 if ((token = strtok(NULL, ",()")) != NULL)
6470 {
6471 TRACE_EVENT_P1("token: %s", token);
6472 setting.type.ton = TON_International;
6473 }
6474 }
6475
6476 TRACE_EVENT_P3("rAT_PercentCCBS(%d, %d, %p)", indct, status, pSetting);
6477 if (pSetting != NULL)
6478 {
6479 TRACE_EVENT_P3("idx = %d: number = %s: ton = %d",
6480 setting.idx, setting.number, setting.type.ton);
6481 }
6482 rAT_PercentCCBS(indct, status, pSetting);
6483 }
6484 else
6485 {
6486 TRACE_EVENT("Unrecognised token");
6487 }
6488 #endif
6489 }
6490 else
6491 {
6492 TRACE_EVENT("No token");
6493 }
6494 }
6495 /* Marcus: CCBS testing: 20/11/2002: End */
6496
6497
6498 /* SPR#1985 - SH - Added this function */
6499
6500 /*
6501 +--------------------------------------------------------------------+
6502 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
6503 | STATE : code ROUTINE: cm_tty_enable |
6504 +--------------------------------------------------------------------+
6505
6506
6507 PURPOSE : Receipt of unsolicited TTY information
6508
6509 */
6510
6511 void rAT_PercentCTYI(T_ACI_CTTY_NEG neg, T_ACI_CTTY_TRX trx)
6512 {
6513 T_MFW_CM_CTYI res;
6514
6515 TRACE_FUNCTION("rAT_PercentCTYI()");
6516
6517 currCmd = AT_CMD_NONE;
6518 switch(neg)
6519 {
6520 case CTTY_NEG_None:
6521 res.neg = CTYI_NONE;
6522 break;
6523 case CTTY_NEG_Request:
6524 res.neg = CTYI_REQUEST;
6525 break;
6526 case CTTY_NEG_Reject:
6527 res.neg = CTYI_REJECT;
6528 break;
6529 case CTTY_NEG_Grant:
6530 res.neg = CTYI_GRANT;
6531 break;
6532 }
6533
6534 cm_signal(E_CM_CTYI, &res);
6535
6536 return;
6537 }
6538
6539
6540 /*
6541 +--------------------------------------------------------------------+
6542 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
6543 | STATE : code ROUTINE: cm_tty_enable |
6544 +--------------------------------------------------------------------+
6545
6546
6547 PURPOSE : Request ACI to switch TTY on or off
6548
6549 */
6550
6551 void cm_tty_enable(UBYTE enable)
6552 {
6553 T_ACI_RETURN ret;
6554
6555 TRACE_FUNCTION("cm_tty_enable()");
6556
6557 /* SPR#1985 - SH - Now use proper ACI functions. */
6558
6559 if (enable)
6560 ret = sAT_PercentCTTY(CMD_SRC_LCL, CTTY_MOD_Enable, CTTY_REQ_On);
6561 else
6562 ret = sAT_PercentCTTY(CMD_SRC_LCL, CTTY_MOD_Enable, CTTY_REQ_Off);
6563
6564 /* SPR#1985 - SH - Check that TTY status has changed and inform MMI */
6565
6566 cm_tty_query();
6567
6568 return;
6569 }
6570
6571
6572 /*
6573 +--------------------------------------------------------------------+
6574 | PROJECT: MMI-Framework (8417) MODULE: MFW_CM |
6575 | STATE : code ROUTINE: cm_tty_query |
6576 +--------------------------------------------------------------------+
6577
6578
6579 PURPOSE : Query status of TTY, inform MMI. */
6580 /*SPR#1985 - SH - Added this function */
6581
6582 void cm_tty_query(void)
6583 {
6584 T_MFW_CM_CTYI res;
6585 // T_ACI_RETURN ret; // RAVI
6586 T_ACI_CTTY_MOD mode;
6587 T_ACI_CTTY_REQ req;
6588 T_ACI_CTTY_STAT stat;
6589 T_ACI_CTTY_TRX trx;
6590
6591 TRACE_FUNCTION("cm_tty_query()");
6592
6593 qAT_PercentCTTY(CMD_SRC_LCL, &mode, &req, &stat, &trx);
6594
6595 res.neg = CTYI_REJECT;
6596
6597 if (req==CTTY_REQ_On)
6598 {
6599 if (req)
6600 res.neg = CTYI_GRANT;
6601 }
6602
6603 cm_signal(E_CM_CTYI, &res);
6604
6605 return;
6606 }
6607
6608 // Feb 03, 2005 REF: CRR 25960 x0012850
6609 // Description: Call Hold: While one call in Active and other in Held by swapping either of phone is not audible
6610
6611 /*
6612 +--------------------------------------------------------------------+
6613 | PROJECT: MMI-Framework MODULE: MFW_CM |
6614 | STATE : code ROUTINE: cm_setSpeechMode |
6615 +--------------------------------------------------------------------+
6616
6617
6618 PURPOSE : MFW function to call psaCC_setSpeechMode() to attach user connection.
6619
6620 */
6621 void cm_setSpeechMode(void)
6622 {
6623 TRACE_FUNCTION("cm_setSpeechMode()");
6624 psaCC_setSpeechMode();
6625 return;
6626 }
6627
6628
6629 // Sep 12, 2005 REF: MMI-SMR-34085 x0021334
6630 // Description: RE: Add +CDIP command - MMI Additions
6631 // Solution: Dummy implementation of function "rAT_PlusCDIP()" is done to enable successful compilation.
6632
6633 /*
6634 +--------------------------------------------------------------------+
6635 | PROJECT: MMI-Framework MODULE: MFW_CM |
6636 | STATE : code ROUTINE : rAT_PlusCDIP |
6637 +--------------------------------------------------------------------+
6638
6639 PURPOSE : Stub implementation
6640 */
6641
6642 GLOBAL void rAT_PlusCDIP( CHAR * number,
6643 T_ACI_TOA * type,
6644 CHAR * subaddr,
6645 T_ACI_TOS * satype)
6646 {
6647 TRACE_FUNCTION ("rAT_PlusCDIP()");
6648 }