FreeCalypso > hg > fc-magnetite
diff src/ui3/mfw/mfw_cm.c @ 420:e8ddbb0837ed
src/ui3: initial import of TCS3/LoCosto BMI & MFW code
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sun, 21 Jan 2018 03:09:00 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/ui3/mfw/mfw_cm.c Sun Jan 21 03:09:00 2018 +0000 @@ -0,0 +1,7243 @@ +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) $Workfile:: mfw_cm.c $| +| $Author:: Ak $Revision:: 1 $| +| CREATED: 3.11.98 $Modtime:: 10.04.00 14:58 $| +| STATE : code | ++--------------------------------------------------------------------+ + + MODULE : MFW_CM + + PURPOSE : This modul contains call management functions. + + HISTORY: + Dec 20, 2006 DR:OMAPS00108192 a0393213(R.Prabakar) + Description : Continous DTMF tones for simultanous keypress + Solution : Bug was due to improper nesting of START-STOP sequence. Now they are avoided. + + Dec 13, 2006 DR:OMAPS00107103 a0393213(R.Prabakar) + Description : No DTMF tones for simultanous keypress + Solution : Once there was some problem in sending DTMF tones, the problem persisted till the next reset. + This was because the queue was not getting flushed once the call was ended. + Now the queue is flushed once the call is ended. + + Nov 30, 2006 DR:OMAPS00105758 a0393213(R.Prabakar) + Description :No DTMF tones after collision of DTMF tones + + Nov 03, 2006 DR: OMAPS00101158 x0pleela + Description : Board crashes after sending atd command through HyperTerminal + Solution : Avoid peforming phonebook search operation if the source id is not LOCAL + - Defined new static variable uOthersrc to set the value to TRUE or FALSE + based on the source Id + - Defined two new function mfw_set_OtherSrc_Value() to set the value of + uOtherSrc to either TRUE or FALSE and mfw_get_OtherSrc_Value + to get the value of uOtherSrc + + Oct 10, 2006 DR: OMAPS00093720 x0039928 + Description : If dial a international number and fail, when auto redail enabled, it will delete '+'. + Solution : MFW_TON_INTERNATIONAL is set for out_call.ton if the dialling number contains '+' + + Sep 01, 2006 REF:OMAPS00090555 x0039928 + Description : When make a MO call,MFW can not get call number from ACI. + Solution : The called number is extracted from the parameter of callCmEvent() + for event E_CM_MO_RES and is displayed. Also stack memory optimization is done to + resolve MMI stack overflow problem. + + June 15, 2006 OMAPS00079492 x0043642 + Description : FT TMO (wk20/06) TC 9.1, 9.2 Multi Party, MS fails to return to idle mode + Solution : assign MFW_CM_DISCONNECT_ALL to variable cmd_hold, and call cm_signal() + + + May 30, 2006 DR: OMAPS00070657 x0pleela + Description: CPHS feature on Locosto-Lite + Solution: For ALS feature, + a) Added definition for new function "mfw_get_ALS_type" + + Apr 25, 2006 OMAPS00075711 a0393213 (R.Prabakar) + Description : 'End Conference' option doesn't work + Solution : The ACI_CHLD_MOD is changed from CHLD_MOD_RelActSpec to CHLD_MOD_RelActAndAcpt while calling sAT_PlusCHLD() + in cm_disconnect(). This is done since CHLD_MOD_RelActSpec with callId 0 is equivalent to sending + AT+CHLD=10 which is invalid according to GSM specification + + Apr 26, 2006 OMAPS00074886 a0393213 (Prabakar R) + Description : No option in MMI to release the held call. + Solution : No option was available. Added a menu option. + + Mar 28, 2006 REF:DR OMAPS00072407 x0039928 + Description: Phone hangs when tried to make an outgoing call + Solution: Reverting back the changes of issue OMAPS00048894 to stop from stack overflow. + + Feb 27, 2006 REF:DR OMAPS00067884 x0039928 + Description: Held call released at locosto phone does not release the call at other end + Solution: if the mode is greater than CHLD_MOD_RelDialCall then sAT_PercentCHLD() is called + instead of sAT_PlusCHLD() + + Jan 27, 2006 REF:DR OMAPS00048894 x0039928 + Description: Outgoing Call: The called number is not displayed while an outgoing call is made + Solution: The called number is extracted from the parameter of callCmEvent() for event E_CM_MO_RES and is displayed. + + Apr 22, 2006 OMAPS00070762 a0393213 (Prabakar R) + Bug : Make MO call from MS1 to MS2. Make MT call from MS3 to MS1. Type at+chld=1 in ATI. + expected behaviour : active call should be released and the incoming call should be accepted + observed behaviour : happens as expected. but display shows incoming call screen only. + active screen is not shown eventhough the connection is established between MS1 and MS3 + Fix : cmd.call_number was not set to 0, which is required in cm_result_cmd() + to call cm_ok_connect()which updates the display. It is set now. + + + Apr 21, 2006 OMAPS00070774 a0393213 (Prabakar R) + Bug : Make MO call from MS1 to MS2. Make MT call from MS3 to MS1. Type at+chld=2 in ATI. + expected behaviour : active call should be put to hold and the incoming call should be accepted + observed behaviour : happens as expected. but display shows incoming call screen only. + active screen is not shown eventhough the connection is established between MS1 and MS3 + Fix : AT commands from CMD_SRC_ATI_3 was not processed. As a result, MFW was not informed of the acceptance of the call + through ATI. In precise cmd_hold variable was not set to MFW_CM_MT_ACCEPT, which is necessary for display update + + + Sep 12, 2005 REF: MMI-SMR-34085 x0021334 + Description: RE: Add +CDIP command - MMI Additions + Solution: Dummy implementation of function "rAT_PlusCDIP()" is done to enable successful compilation. + Nov 02, 2005 DR OMAPS00052132 xdeepadh + Bug:Not able to access the SMS inbox and also not able to send SMS in Locosto Lite build + Fix: The ATI Enums usage has been put under the FF_ATI flag. + + Aug 10, 2005 REF: MMI-SPR-30099 x0018858 + Description: During a held communication, if the user presses 4 and send then there is no response from network. + Solution: Modified the return value and also added a case statement to handle the response received. + + Apr 07 2005 REF: CRR 29989 xpradipg + Description: Optimisation 3: replace the static global data with dynamic + allocation / deallocation + Solution: The static global variables are dynamically allocated and + deallocated + + Apr 03, 2005 REF: CRR 29988 - xpradipg + Description: Optimisation 2: Reduce the keyboard buffer and the dtmf buffer + size + Solution : The dtmf buffer is reduced to 20 from 50 + + Apr 14, 2005 REF: CRR 29991 xpradipg + Description: Optimisation 5: Remove the static allocation and use dynamic + allocation/ deallocation for pb_list and black_list + Solution: The static definition is removed and replaced with the dynamic + allocation + + Feb 03, 200 REF: CRR 25960 x0012850 + Description: Call Hold: While one call in Active and other in Held by swapping either of phone is not audible + Solution: swapping action results in one of the calls getting muted. We attach user connection again. + + Aug 23, 2004 REF: CRR 22222 xkundadu + Bug: Runaway Call Waiting Tone. + Call Waiting tone doesnot stop after ansering waiting call. + + Fix: Handle the AT-Command source id CMD_SRC_ATI_2 also for call control + callback functions. + + Jun 05, 2004 REF: CRR 18262 NISHIKANT KULKARNI + Description: The sample sends a STOP DTMF message without release of the key by the user + Solution: Instead of sending DTMF commands in "VTS_MOD_Auto" mode, on key press DTMF tone is started + using VTS_MOD_ManStart and on key release DTMF tone is stopped using VTS_MOD_ManStop mode. + + // Apr 26, 2004 REF: CRR 16545 Ajith K P and Side effect of CRR 16545. + // Issue description: When the user enters 11SEND and if the first call is + // HELD call,the held call disconnects. This should not happen. + // Problem was, though sAT_PlusCHLD(..) is expected to disconnect an ACTIVE + // call only, it was disconnecting HELD call rather than returning AT_FAIL. + // If sAT_PlusCHLD() Fails, Send the user entered string as USSD to network using sAT-Dn(). + // So now if the user wants to release a HELD call, in cm_disconect() we are calling the + // sAT_PlusCHLD(..) function with C + + + Mar 28, 2006 REF:ER OMAPS00071798 x0043642 + Added new options in BMI to accept the value for tty audio mode, + and the accepted value is passed as parameter in function call sAT_PercentCTTY + +*/ + +#define ENTITY_MFW + +#include <string.h> +#include <stdio.h> +#include <stdlib.h> + +#if defined (NEW_FRAME) + +#include "typedefs.h" +#include "vsi.h" +#include "pei.h" +#include "custom.h" +#include "gsm.h" + +#else + +#include "STDDEFS.H" +#include "custom.h" +#include "gsm.h" +#include "vsi.h" + +#endif + + +#include "mfw_mfw.h" +#include "mfw_phb.h" +#include "mfw_phbi.h" +#include "mfw_cm.h" +#include "mfw_cmi.h" +#include "mfw_nm.h" +#include "mfw_sim.h" +#include "mfw_sima.h" +#include "mfw_nmi.h" +#include "mfw_simi.h" +#include "mfw_win.h" + +#include "mfw_tim.h" +#include "mfw_utils.h" + +#include "ksd.h" +#include "psa.h" + +#if defined (FAX_AND_DATA) +#include "aci_fd.h" +#endif + +#include "cmh.h" +#include "phb.h" +#include "cmh_phb.h" + +#include "mfw_ss.h" +#include "mfw_ssi.h" +#include "mfw_win.h" +#include "mfw_ffs.h" + +#include "prim.h" +#ifndef PCM_2_FFS +#include "pcm.h" +#endif + + + +/* + * Conditional compilation flag for CCBS testing. + * When defined, the cm_ccbs_... functions do not call ACI functions but + * simply set the return value variable to indicate success. Also the body + * of the rAT_PercentMMITEST function is defined for parsing AT%MMITEST + * commands and calling ACI/MFW functions as if CCBS events had occured. + */ +// #define CCBS_TEST + +/********* current define *******************************************/ +// Apr 14, 2005 REF: CRR 29991 xpradipg +// remove the static definition +#ifndef FF_MMI_OPTIM +static T_MFW_CM_BLACKLIST_LIST black_list; +#endif + +// Apr 06 2005 REF: CRR 29989 xpradipg +// The definition of global is removed since it is locally used +#ifndef FF_MMI_OPTIM +static T_ACI_CAL_ENTR call_tab[MAX_CALL_NR]; +#endif +static T_MFW_PHB_LIST entries; +static T_MFW_CM_CC_STAT cc_stat; /* current outgoing call status */ +static T_MFW_CM_COMMAND cmd; +static T_MFW_CM_NOTIFY notify; + +static UBYTE call_type; /* indicate an ECC call or normal call */ +static UBYTE call_stat; /* indicate an MO call or MT call */ +/*a0393213 lint WR:symbol not referenced soln:the variable is put under the flag (which won't be defined) so that the flag + can be removed if the variable is necessary*/ +#ifdef MMI_LINT_WARNING_REMOVAL +static SHORT cc_id; /* current call index */ +#endif +static UBYTE redial_stat; +static UBYTE redial_count; +static UBYTE cmd_hold; + +static T_MFW_CM_CW_INFO in_call; +static T_MFW_CM_MO_INFO out_call; +static T_MFW_CM_DISCONNECT dis_connect; +static T_MFW_CM_REDIAL rdl; +static T_MFW_CM_CPI cm_cpi; +/* Marcus: CCBS: 14/11/2002: Start */ +static T_MFW_CM_CCBS_INFO ccbs_info; // E_CM_CCBS data +static T_MFW_CM_CCBS_OP ccbs_op = CM_CCBS_NONE; // Current CCBS operation +/* Marcus: CCBS: 14/11/2002: End */ + +static T_CM_CLI cli_prefix; +/*CONQUEST 5998-MC 30/04/02 -initialised timers to zero (prevents corruption) */ +static MfwHnd redialTim1= NULL; /* the 1th redialing */ +static MfwHnd redialTim24 = NULL; /* the 2th to 4st redialing */ +static MfwHnd redialTim5 = NULL; /* the 5th or over redialing */ + +static int cmCommand (U32 cmd, void *h); /* handle window commands */ +static int cm_redial_timeout(MfwEvt e, MfwTim *t); +static char currAccepting = 0; /* ES!! 210999 */ +static char currConnecting = 0; /* ES!! 290999 */ +/*a0393213 lint WR:symbol not referenced soln:the variable is put under the flag (which won't be defined) so that the flag + can be removed if the variable is necessary*/ +#ifdef MMI_LINT_WARNING_REMOVAL +static T_ACI_AT_CMD currCmd; +#endif +static T_MFW_CM_DTMF dtmf_sent={FALSE};/*OMAPS00108192 a0393213 - variable which keeps track of the dtmf sent to ACI (via sAT_PlusVTS)*/ +static T_MFW_CM_DTMF dtmf_queued={FALSE};/*OMAPS00108192 a0393213 - variable which keeps track of the recent dtmf added to the queue*/ +void cm_force_disconnect(void); // RAVI + +/* June 15, 2006 OMAPS00079492 x0043642 */ +void set_cmdHold(int command); + +//APR 03 2005 - REF CRR: 29988 xpradipg +//The DTMF buffer is reduced from 50 to 20 +#ifdef FF_MMI_REDUCED_KBD_BUFFER +#define MAX_DTMF_Q_ENTRIES 20 +#else +#define MAX_DTMF_Q_ENTRIES 50 +#endif +#define CPI_CAUSE_MASK 0xFF /* cq11676 cause mask 17-02-04 MZ */ +static UBYTE dtmf_q[MAX_DTMF_Q_ENTRIES]; +static SHORT mfw_cm_dtmf_q_id; + +// MMI-SPR 13873 xkundadu. +// Added this boolean variable to check whether a particular call is in +// multiparty or not +BOOL bIsMultpty = FALSE; + +EXTERN MfwHdr * current_mfw_elem; + +LOCAL T_MFW_CM_CALL_STAT cm_cvt_call_status( T_ACI_CAL_STAT stat ); + +//x0pleela 03 Nov, 2006 DR: OMAPS00101158 +//Variable which says the type of source Id +//FALSE if LOCAL SRC, TRUE if other sources like AT1, AT2, AT3... +static UBYTE uOtherSrc; +//function to set the value of uOtherSrc to either TRUE or FALSE +GLOBAL void mfw_set_OtherSrc_Value(UBYTE otherSrc); +//function to get the value of uOtherSrc +GLOBAL UBYTE mfw_get_OtherSrc_Value(void); +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_init | ++--------------------------------------------------------------------+ + + + PURPOSE : initialize for call management + +*/ + +void cm_init(void) +{ +// Apr 14, 2005 REF: CRR 29991 xpradipg +// local variable definition +#ifdef FF_MMI_OPTIM + T_MFW_CM_BLACKLIST_LIST black_list; + /*a0393213 compiler warnings removal- removed variable 'file'*/ +#endif + TRACE_FUNCTION ("cm_init()"); + memset(&black_list, 0, sizeof(T_MFW_CM_BLACKLIST_LIST)); +// Apr 14, 2005 REF: CRR 29991 xpradipg +// Since the blacklist is not persistent across powercycles we reset the file +// contents +#ifdef FF_MMI_OPTIM + if( flash_MMI_blackList_write((U8 *)&black_list, sizeof(T_MFW_CM_BLACKLIST_LIST),0) < 0) + TRACE_EVENT("Error opening the black list file"); +#endif + + currAccepting = 0; /* ES!! 210999 */ + currConnecting = 0; /* ES!! 290999 */ + + call_type = MFW_CALL_FREE; + call_stat = MFW_CALL_FREE; + cc_stat.type = MFW_CALL_FREE; + #ifdef MMI_LINT_WARNING_REMOVAL /*a0393213 lint warnings removal*/ + cc_id = 0; + #endif + + cmd_hold = 0; + #ifdef MMI_LINT_WARNING_REMOVAL /*a0393213 lint warnings removal*/ + currCmd = AT_CMD_NONE; + #endif + +// get prefix from EEPROM + cli_prefix = 0; + + /* create time event for redialing */ + redialTim1 = timCreate (0, MIN_DURATION_1, (MfwCb)cm_redial_timeout); + redialTim24 = timCreate (0, MIN_DURATION_2_4, (MfwCb)cm_redial_timeout); + redialTim5 = timCreate (0, MIN_DURATION_5, (MfwCb)cm_redial_timeout); + + redial_stat = (UBYTE)FFS_flashData.redial_mode; + + mfwCommand[MfwTypCm] = (MfwCb) cmCommand; + +/* +** Create a static circular buffer to hold the dtmf tones +*/ + mfw_cm_dtmf_q_id = mfw_cbuf_create( MAX_DTMF_Q_ENTRIES, + sizeof(UBYTE), + 0, + 0xFF, + TRUE, + (void *)&dtmf_q[0]); + + if (mfw_cm_dtmf_q_id < 0) + TRACE_EVENT_P1("ERROR : mfw_cbuf_create failed with error value %d", mfw_cm_dtmf_q_id); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_exit | ++--------------------------------------------------------------------+ + + + PURPOSE : + +*/ + +void cm_exit(void) +{ + TRACE_FUNCTION ("cm_exit()"); + + /* delete time event for redialing */ + timDelete (redialTim5); + timDelete (redialTim24); + timDelete (redialTim1); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_create | ++--------------------------------------------------------------------+ + + + PURPOSE : create event for call management + +*/ + +T_MFW_HND cm_create(T_MFW_HND hWin, T_MFW_EVENT event, T_MFW_CB cbfunc) +{ + T_MFW_HDR *hdr; + T_MFW_CM *cm_para; + + TRACE_FUNCTION ("cm_create()"); + + hdr = (T_MFW_HDR *) mfwAlloc(sizeof (T_MFW_HDR)); + cm_para = (T_MFW_CM *) mfwAlloc(sizeof (T_MFW_CM)); + + if (!hdr OR !cm_para) + return FALSE; + + /* + * initialisation of the handler + */ + cm_para->emask = event; + cm_para->handler = cbfunc; + + hdr->data = cm_para; /* store parameter in node */ + hdr->type = MFW_TYP_CM; /* store type of event handler */ + + /* + * installation of the handler + */ + return mfwInsert((T_MFW_HDR *)hWin, hdr); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_delete | ++--------------------------------------------------------------------+ + + + PURPOSE : delete a event for call management + +*/ + +T_MFW_RES cm_delete(T_MFW_HND h) +{ + TRACE_FUNCTION ("cm_delete()"); + + if (!h OR !((T_MFW_HDR *)h)->data) + return MFW_RES_ILL_HND; + + if (!mfwRemove((T_MFW_HDR *)h)) + return MFW_RES_ILL_HND; + + mfwFree((U8 *)(((T_MFW_HDR *) h)->data),sizeof(T_MFW_CM)); + mfwFree((U8 *)h,sizeof(T_MFW_HDR)); + + return MFW_RES_OK; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_signal | ++--------------------------------------------------------------------+ + + PURPOSE : send a event signal. + +*/ + +void cm_signal(T_MFW_EVENT event, void * para) +{ + UBYTE temp; + + + + temp = dspl_Enable(0); + + +if (mfwSignallingMethod EQ 0) + { + /* + * focus is on a window + */ + if (mfwFocus) + /* + * send event to sim management + * handler if available + */ + if (cm_sign_exec (mfwFocus, event, para)) + { + dspl_Enable(temp); + return; + } + + /* + * acutal focussed window is not available + * or has no network management registration + * handler, then search all nodes from the root. + */ + if (mfwRoot) + cm_sign_exec (mfwRoot, event, para); + } + else + { + MfwHdr * h = 0; + + /* + * Focus set, then start here + */ + if (mfwFocus) + h = mfwFocus; + /* + * Focus not set, then start root + */ + if (!h) + h = mfwRoot; + + /* + * No elements available, return + */ + + while (h) + + + { + /* + * Signal consumed, then return + */ + if (cm_sign_exec (h, event, para)) + { + dspl_Enable(temp); + return; + } + + /* + * All windows tried inclusive root + */ + if (h == mfwRoot) + { + dspl_Enable(temp); + return; + } + + /* + * get parent window + */ + h = mfwParent(mfwParent(h)); + if(h) + h = ((MfwWin * )(h->data))->elems; + } + cm_sign_exec (mfwRoot, event, para); + } + dspl_Enable(temp); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_sign_exec | ++--------------------------------------------------------------------+ + + + PURPOSE : Send a signal if CM management handler. + +*/ + +BOOL cm_sign_exec (T_MFW_HDR * cur_elem, T_MFW_EVENT event, T_MFW_CM_PARA * para) +{ + TRACE_FUNCTION ("cm_sign_exec()"); + + while (cur_elem) + { + /* + * event handler is available + */ + if (cur_elem->type EQ MFW_TYP_CM) + { + T_MFW_CM * cm_data; + /* + * handler is CM management handler + */ + cm_data = (T_MFW_CM *)cur_elem->data; + if (cm_data->emask & event) + { + /* + * event is expected by the call back function + */ + cm_data->event = event; + switch (event) + { + case E_CM_COLP: + memcpy (&cm_data->para.mo_data, para, sizeof (T_MFW_CM_MO_INFO)); + break; + + case E_CM_DISCONNECT: + memcpy (&cm_data->para.disconnect, para, sizeof (T_MFW_CM_DISCONNECT)); + break; + case E_CM_DISCONNECT_ALL: + memcpy (&cm_data->para.disconnect_all, para, sizeof (T_MFW_CM_DISCONNECT_ALL)); + break; + + case E_CM_CW: + memcpy (&cm_data->para.cw_info, para, sizeof (T_MFW_CM_CW_INFO)); + break; + + case E_CM_COMMAND: + memcpy (&cm_data->para.command, para, sizeof (T_MFW_CM_COMMAND)); + break; + + case E_CM_AOC: + memcpy (&cm_data->para.aoc_info, para, sizeof (T_MFW_CM_AOC_INFO)); + break; + + case E_CM_REDIAL: + memcpy (&cm_data->para.rdl, para, sizeof (T_MFW_CM_REDIAL)); + break; + + case E_CM_CONNECT_ACK: + memcpy (&cm_data->para.call_id, para, sizeof (SHORT)); + break; + +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +// Fix: Copy MO data + case E_CM_MO_RES: + memcpy (&cm_data->para.mo_data, para, sizeof (T_MFW_CM_MO_INFO)); + break; + + case E_CM_CPI: + memcpy (&cm_data->para.cm_cpi, para, sizeof (T_MFW_CM_CPI)); + break; + + case E_CM_RING_OFF: + break; + + case E_CM_AOC_CNF: + memcpy (&cm_data->para.aoc_cnf, para, sizeof (T_MFW_CM_AOC_CNF)); + break; + + case E_CM_DTMF: + memcpy (&cm_data->para.dtmf_tone, para, sizeof (UBYTE)); + break; + + case E_CM_NOTIFY: + memcpy (&cm_data->para.notify, para, sizeof (T_MFW_CM_NOTIFY)); + break; + /*MC SPR 1392*/ + case E_CM_CALL_DEFLECT_STATUS: + memcpy (&cm_data->para.call_deflect_status, para, sizeof (BOOL)); + break; + /* Marcus: CCBS: 14/11/2002: Start */ + case E_CM_CCBS: + TRACE_EVENT("E_CM_CCBS"); + memcpy (&cm_data->para.ccbs, para, sizeof (T_MFW_CM_CCBS_INFO)); + break; + /* Marcus: CCBS: 14/11/2002: End */ + + case E_CM_CTYI: + memcpy (&cm_data->para.ctyi, para, sizeof (T_MFW_CM_CTYI)); + break; + + } + + /* + * if call back defined, call it + */ + if (cm_data->handler) + { + // PATCH LE 06.06.00 + // store current mfw elem + current_mfw_elem = cur_elem; + // END PATCH LE 06.06.00 + if ((*(cm_data->handler)) (cm_data->event, (void *)&cm_data->para)) + return TRUE; + } + } + } + cur_elem = cur_elem->next; + } + return FALSE; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_callTyp_cvt | ++--------------------------------------------------------------------+ + + + PURPOSE : This function is used to convert the type of call class + used by MFW to the type of call class used by ACI. + +*/ + +LOCAL T_MFW_CM_CALL_TYPE cm_callTyp_cvt(T_ACI_CLASS cls) +{ + switch ( cls ) + { + case ( CLASS_Vce ) : return VOICE_CALL; + case ( CLASS_AuxVce): return AuxVOICE_CALL; + case ( CLASS_Dat ) : return DATA_CALL; + case ( CLASS_Fax ) : return FAX_CALL; + case ( CLASS_VceDat ) : + case ( CLASS_VceFax ) : + case ( CLASS_DatFax ) : + case ( CLASS_VceDatFax ): return (T_MFW_CM_CALL_TYPE)cls; + case ( CLASS_None ) : return NONE_TYPE; + case (CLASS_NotPresent): return NONE_TYPE; + + default: return NONE_TYPE; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_search_callId | ++--------------------------------------------------------------------+ + + + PURPOSE : find call index from call table + +*/ + +int cm_search_callId(T_ACI_CAL_STAT type, SHORT *id) +{ + int i; +// Apr 06 2005 REF: CRR 29989 xpradipg +// Local definition and allocation +#ifdef FF_MMI_OPTIM + T_ACI_CAL_ENTR *call_tab; + *id = 0; + call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); + if(NULL == call_tab) + return CM_ERROR; +#else + *id = 0; +#endif + TRACE_FUNCTION("cm_search_callId()"); + + + if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) != AT_CMPL) + { +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocation of memory allocated +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return CM_ERROR; + } + + for (i=0; i<MAX_CALL_NR; i++) + { + if (call_tab[i].index == -1) + break; + + if (call_tab[i].status == type) + { + *id = call_tab[i].index; +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocation of memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return CM_OK; + } + + } +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocation of memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return CM_ERROR; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_search_callMode | ++--------------------------------------------------------------------+ + + + PURPOSE : find call type from call table + +*/ + +T_ACI_CAL_MODE cm_search_callMode(SHORT id) +{ + int i; +// Apr 06 2005 REF: CRR 29989 xpradipg +// allocation of memory, if the memory allocation fails then we return the +// error value same as when the qAT_PercentCAL() fails +#ifdef FF_MMI_OPTIM + T_ACI_CAL_ENTR *call_tab;//[MAX_CALL_NR]; + T_ACI_CAL_MODE calMode; + call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); + if(NULL == call_tab) + return CAL_MODE_Unknown; +#endif + + TRACE_FUNCTION("cm_search_callMode()"); + + if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) != AT_CMPL) + { +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return CAL_MODE_Unknown; + } + for (i=0; i<MAX_CALL_NR; i++) + { + if (call_tab[i].index == -1) + break; + + if (call_tab[i].index == id) + { +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + calMode = call_tab[i].calMode; + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); + return calMode; +#else + return call_tab[i].calMode; +#endif + } + } +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return CAL_MODE_Unknown; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_search_mptyId | + + + PURPOSE : find multiparty call index from call table + +*/ + +int cm_search_mptyId(T_ACI_CAL_MPTY type, SHORT *id) +{ + int i; +// Apr 06 2005 REF: CRR 29989 xpradipg +// allocate memory +#ifdef FF_MMI_OPTIM + T_ACI_CAL_ENTR *call_tab;//[MAX_CALL_NR]; + call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); + if( NULL == call_tab) + return CM_ERROR; +#endif + + TRACE_FUNCTION("cm_search_mptyId()"); + *id = 0; + + if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) != AT_CMPL) + { +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return CM_ERROR; + } + for (i=0; i<MAX_CALL_NR; i++) + { + if (call_tab[i].index == -1) + break; + + if (call_tab[i].mpty == type) + { + *id = call_tab[i].index; +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return CM_OK; + } + } +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return CM_ERROR; +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_search_numId | ++-------------------------------------------------------------------+ + PURPOSE : find call index from call table +*/ +/*a0393213(R.Prabakar) lint warnings removal + warning:symbol(cm_search_numId) not referenced + soln :this function was not at all called. so this function has been put under MMI_LINT_WARNING_REMOVAL, + which is not defined. If this function is needed this flag can be removed*/ + +#ifdef MMI_LINT_WARNING_REMOVAL +LOCAL SHORT cm_search_numId(UBYTE *number) +{ + int i; +// Apr 06 2005 REF: CRR 29989 xpradipg +// allocate memory +#ifdef FF_MMI_OPTIM + SHORT index; + T_ACI_CAL_ENTR *call_tab;//[MAX_CALL_NR]; + call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); + if(NULL == call_tab) + return 0; +#endif + + TRACE_FUNCTION("cm_search_numId()"); + + if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) != AT_CMPL) + { +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return 0; + } + + for (i=0; i<MAX_CALL_NR; i++) + { + if (call_tab[i].index == -1) + break; + + if (!strcmp(call_tab[i].number, (char *)number)) + { +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + index = call_tab[i].index; + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); + return index; +#else + return call_tab[i].index; +#endif + } + } +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return 0; +} + +#endif +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_search_callStat | ++--------------------------------------------------------------------+ + + + PURPOSE : Search the information from call table. + +*/ + +T_MFW cm_search_callStat(SHORT call_number, + T_MFW_CM_CALL_STAT *stat, + UBYTE *ton, + UBYTE *mode) +{ + int i; +// Apr 06 2005 REF: CRR 29989 xpradipg +// allocat memory +#ifdef FF_MMI_OPTIM + T_ACI_CAL_ENTR *call_tab;//[MAX_CALL_NR]; + call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); + if( NULL == call_tab) + return CM_ERROR; +#endif + + if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) EQ AT_CMPL) + { + for (i=0; i<MAX_CALL_NR; i++) + { + if (call_tab[i].index == -1) + break; + + if (call_tab[i].index == call_number) + { + *stat = cm_cvt_call_status(call_tab[i].status); + *ton = phb_cvtTon(call_tab[i].type.ton); + *mode = cm_cvt_call_mode(call_tab[i].calMode); +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + + return CM_OK; + } + } +// Apr 06 2005 REF: CRR 29989 xpradipg +// this will be returned once we get out of the if statement +#ifndef FF_MMI_OPTIM + return CM_ERROR; +#endif + } +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return CM_ERROR; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_check_emergency | ++--------------------------------------------------------------------+ + + + PURPOSE : Check emergency call number + +*/ + +T_MFW cm_check_emergency(UBYTE *number) +{ + //UBYTE index; // RAVI + // T_MFW_PHB_TEXT findText; // RAVI + // T_MFW_PHB_ENTRY entry; // RAVI + + TRACE_FUNCTION ("cm_check_emergency()"); + TRACE_EVENT_P1("String being passed = %s", (char*)number); + +//TISH, patch for OMAPS00125064 + if (strlen((char *)number) <= 0 OR strlen((char *)number) > 6) + //if (strlen((char *)number) <= 0 OR strlen((char *)number) > 3) + return FALSE; + + if(psaCC_phbSrchECC((char*)number, FALSE)) + { + TRACE_EVENT("psaCC_phbSrchECC - returned - TRUE"); + return TRUE; + } + else + { + TRACE_EVENT("psaCC_phbSrchECC - returned - FALSE"); + return FALSE; + } + +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_mo_prefix | ++--------------------------------------------------------------------+ + + + PURPOSE : set/get CLIP, CLIR, COLP and COLR tempstatus + +*/ + +T_CM_CLI cm_mo_prefix(T_CM_CLI prefix) +{ + UBYTE bits; + + if ((bits = (prefix & 0x0c)) != 0) + cli_prefix = (cli_prefix & 0xf3) | bits; + if ((bits = (prefix & 0xc0)) != 0) + cli_prefix = (cli_prefix & 0x3f) | bits; + return cli_prefix; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_set_cmd_status | ++--------------------------------------------------------------------+ + + + PURPOSE : + +*/ + +void cm_set_cmd_status(T_ACI_CHLD_MOD mode, CHAR* call) +{ + SHORT id; + // Added xkundadu MMI-SPR 13873 + // Stores the status of a particular call. + T_MFW_CM_STATUS status; + + TRACE_FUNCTION("cm_set_cmd_status()"); // Marcus: CCBS: 14/11/2002 + + memset(&dis_connect, 0, sizeof(T_MFW_CM_DISCONNECT)); + memset(&cmd, 0, sizeof(T_MFW_CM_COMMAND)); + switch (mode) + { + case CHLD_MOD_RelHldOrUdub: + TRACE_EVENT("CHLD_MOD_RelHldOrUdub"); // Marcus: CCBS: 14/11/2002 + /*SPR#1965 - DS - Changed from MFW_CM_MT_REJECT to MFW_CM_TERMINATED because + * the E_CM_DISCONNECT signal is not sent in cm_ok_disconnect() if cmd_hold = MFW_CM_MT_REJECT. + * Port of 1962. + */ + cmd_hold = MFW_CM_TERMINATED; + + if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK) + { + TRACE_EVENT("cm_search_callId(CAL_STAT_Wait, &id) == CM_OK"); // Marcus: CCBS: 14/11/2002 + dis_connect.call_number = id; + } + else + { + TRACE_EVENT("cm_search_callId(CAL_STAT_Wait, &id) != CM_OK"); // Marcus: CCBS: 14/11/2002 + dis_connect.call_number = -1; // call id? + } + + break; + case CHLD_MOD_RelActAndAcpt: + + TRACE_EVENT("CHLD_MOD_RelActAndAcpt"); // Marcus: CCBS: 14/11/2002 + cmd_hold = MFW_CM_1_SEND; + + // Added xkundadu MMI-SPR 13873 + // Querying if there are any active calls, storing the index of the + // call and setting a flag if found to be multiparty. + if (cm_search_callId(CAL_STAT_Active, &id) == CM_OK) + { + // Active call is present. + dis_connect.call_number = id; // call id ? + cm_status(id, &status, 1); + if (status.mtpy EQ MFW_MTPY_MEMBER) + { + bIsMultpty = TRUE; + } + else + { + bIsMultpty = FALSE; + } + + } + else + { + dis_connect.call_number = -1; + } + // Added xkundadu MMI-SPR 13873 + // Querying if there are any held calls, storing the index of the call + // to change the status to active call. + if (cm_search_callId(CAL_STAT_Held, &id) == CM_OK) + { + cmd.command = CM_RETRIEVE; + cmd.call_number = id; + } + // Added xkundadu MMI-SPR 13873 + // Checking is there any waiting call exists or not. + if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK) + { + // This variable determines whether to accept/reject the call + // in the cm_result_cmd(). + cmd.call_number=0; + } + else + { + cmd.call_number=-1; + } + + break; + + case CHLD_MOD_RelActSpec: + TRACE_EVENT("CHLD_MOD_RelActSpec"); // Marcus: CCBS: 14/11/2002 + dis_connect.call_number = (SHORT)atoi(call); + if (dis_connect.call_number) + { + TRACE_EVENT("dis_connect.call_number"); // Marcus: CCBS: 14/11/2002 + cmd_hold = MFW_CM_TERMINATED; + } + else + { + TRACE_EVENT("!dis_connect.call_number"); // Marcus: CCBS: 14/11/2002 + cmd_hold = MFW_CM_MPTY_TERMINATED; + } + break; + case CHLD_MOD_HldActAndAcpt: + TRACE_EVENT("CHLD_MOD_HldActAndAcpt"); // Marcus: CCBS: 14/11/2002 + if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK) + { + TRACE_EVENT("cm_search_callId(CAL_STAT_Wait, &id) == CM_OK"); // Marcus: CCBS: 14/11/2002 + cmd_hold = MFW_CM_MT_ACCEPT; + /* + * initialize for result event + */ + cmd.command = CM_HOLD; + #ifdef MMI_LINT_WARNING_REMOVAL /*a0393213 lint warnings removal*/ + cc_id = id; + #endif + } + else + { + TRACE_EVENT("cm_search_callId(CAL_STAT_Wait, &id) != CM_OK"); // Marcus: CCBS: 14/11/2002 + if ((cm_search_callId(CAL_STAT_Active, &id) == CM_OK) + AND (cm_search_callId(CAL_STAT_Held, &id) == CM_OK)) + { + TRACE_EVENT("cmd.command = CM_SWAP"); // Marcus: CCBS: 14/11/2002 + cmd.command = CM_SWAP; + } + if ((cm_search_callId(CAL_STAT_Active, &id) != CM_OK) + AND (cm_search_callId(CAL_STAT_Held, &id) == CM_OK)) + { + TRACE_EVENT("cmd.command = CM_RETRIEVE"); // Marcus: CCBS: 14/11/2002 + cmd.command = CM_RETRIEVE; + } + if ((cm_search_callId(CAL_STAT_Active, &id) == CM_OK) + AND (cm_search_callId(CAL_STAT_Held, &id) != CM_OK)) + { + TRACE_EVENT("cmd.command = CM_HOLD"); // Marcus: CCBS: 14/11/2002 + cmd.command = CM_HOLD; + } + cmd.call_number = 0; + } + break; + case CHLD_MOD_HldActExc: + TRACE_EVENT("CHLD_MOD_HldActExc"); // Marcus: CCBS: 14/11/2002 + cmd.command = CM_SPLIT_MULTIPARTY; + cmd.call_number = 0; + break; + case CHLD_MOD_AddHld: + TRACE_EVENT("CHLD_MOD_AddHld"); // Marcus: CCBS: 14/11/2002 + cmd.command = CM_BUILD_MULTIPARTY; + cmd.call_number = 0; + break; + case CHLD_MOD_Ect: + TRACE_EVENT("CHLD_MOD_Ect"); // Marcus: CCBS: 14/11/2002 + cmd.command = CM_ETC; + cmd.call_number = 0; + break; + case CHLD_MOD_Ccbs: + TRACE_EVENT("CHLD_MOD_Ccbs"); // Marcus: CCBS: 14/11/2002 + cmd.command = CM_CCBS; + cmd.call_number = 0; + break; + case CHLD_MOD_HldActDial: + TRACE_EVENT("CHLD_MOD_HldActDial"); // Marcus: CCBS: 14/11/2002 + cmd_hold = MFW_CM_HOLD_AND_DIAL; + /* + * initialize for result event + */ + cmd.command = CM_HOLD; + /*cc_id = id;*//*a0393213 lint warnings:var not initialized soln:commented as it is not needed*/ + break; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_check_mo_number | ++--------------------------------------------------------------------+ + + + PURPOSE : start mobile originated call + +*/ + +T_MFW cm_check_mo_number(UBYTE *number) +{ + UBYTE i; +// Apr 14, 2005 REF: CRR 29991 xpradipg +// local definition + #ifdef FF_MMI_OPTIM + UBYTE count = 0; + UBYTE blackListNum[MFW_NUM_LEN]; + int8 file; + #endif + + /* check whether a redialing exists */ + if (call_stat EQ REDIALING_CALL) + { + cm_stop_redialTim(); + rdl.redial_mode = CM_REDIAL_OUTGOING; + cm_signal(E_CM_REDIAL, &rdl); + } + + + if (!number) + return CM_OK; +// Apr 14, 2005 REF: CRR 29991 xpradipg +// the list is read from the file +#ifdef FF_MMI_OPTIM + if(( file = flash_MMI_blackList_open()) > 0) + { + if(flash_MMI_blackList_read(file,(U8*)&count,1,0) > 0) + { + for(i=0; i < (int)count; i++) + { + if(flash_MMI_blackList_read(file,(U8*)blackListNum,MFW_NUM_LEN,(i*MFW_NUM_LEN)+1) > 0) + { + if(!strcmp((char*)blackListNum, (char*)number)) + { + flash_MMI_blackList_close(file); + return CM_BLACKLIST; + } + } + } + } + flash_MMI_blackList_close(file); + } +#else + /* check whether this number is in blacklist */ + for (i=0; i<black_list.count; i++) + { + if (!strcmp((char *)black_list.number[i], (char *)number)) + return CM_BLACKLIST; + } +#endif + + /* check the type of this number */ + if (cm_check_emergency(number) EQ TRUE) + call_type = MFW_ECC_CALL; + else + call_type = MFW_NORMAL_CALL; + + return CM_OK; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_set_call_mode | ++--------------------------------------------------------------------+ + + + PURPOSE : set call mode + +*/ + +void cm_set_call_mode(T_MFW_CM_CALL_TYPE mode) +{ + switch (mode) + { + case VOICE_CALL: + case AuxVOICE_CALL: /*MC, SPR 1026, assume line 2 is handled like line 1*/ + case DATA_CALL: + case FAX_CALL: + sAT_PlusCMOD(CMD_SRC_LCL, CMOD_MOD_Single); + break; + case VFD_VOICE: + case VFD_DATA: + sAT_PlusCMOD(CMD_SRC_LCL, CMOD_MOD_VoiceFlwdDat); + break; + case VAD_VOICE: + case VAD_DATA: + sAT_PlusCMOD(CMD_SRC_LCL, CMOD_MOD_VoiceDat); + break; + case VAF_VOICE: + case VAF_FAX: + sAT_PlusCMOD(CMD_SRC_LCL, CMOD_MOD_VoiceFax); + break; + default: + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_mo_idx | ++--------------------------------------------------------------------+ + + + PURPOSE : start mobile originated call + +*/ + +T_MFW cm_mo_idx(T_KSD_SEQPARAM *para, T_MFW_CM_CALL_TYPE mode) +{ + T_MFW_PHB_LIST entries; + T_MFW_PHB_ENTRY entry; + T_ACI_RETURN aci_response; /*a0393213 compiler warnings removal - type of var changed*/ + T_MFW mfw_response; /*a0393213 compiler warnings removal - a var introduced*/ +//RM 19_09_2000 +#ifdef NO_ASCIIZ + T_ACI_PB_TEXT mfwpbText; +#endif +//RM + + entries.entry = &entry; + + /* search this number from phonebook */ + if ((phb_read_entries(PHB_ADN, (UBYTE)para->dialIdx.index, + MFW_PHB_INDEX, 1, + &entries) EQ MFW_PHB_OK) + AND ((int)entries.num_entries > 0)) + { + mfw_response= cm_check_mo_number(entries.entry->number); + if (mfw_response NEQ CM_OK) + return mfw_response; + } + else + { + mfw_response = cm_check_mo_number(0); + if (mfw_response NEQ CM_OK) + return mfw_response; + } + + /* set the outgoing call status */ + call_stat = OUTGOING_CALL; + redial_count = 0; + cc_stat.type = OUTGOING_CALL; + + cm_set_call_mode(mode); + +//RM 19_09_2000 instead change in ksd structure T_KSD_SEQPARAM etc., later to change !!!! +#ifdef NO_ASCIIZ + if(para->dialIdx.str NEQ NULL) + { + mfwpbText.cs = CS_GsmDef; + mfwpbText.len = strlen(para->dialIdx.str); + memcpy(mfwpbText.data,para->dialIdx.str,mfwpbText.len); + } + else + { + mfwpbText.cs = CS_NotPresent; + mfwpbText.len = 0; + } + aci_response= sAT_Dm(CMD_SRC_LCL, &mfwpbText, + para->dialIdx.mem, para->dialIdx.index, + para->dialIdx.clirOvrd, para->dialIdx.cugCtrl, + para->dialIdx.callType); +#else + aci_response= sAT_Dm(CMD_SRC_LCL, para->dialIdx.str, + para->dialIdx.mem, para->dialIdx.index, + para->dialIdx.clirOvrd, para->dialIdx.cugCtrl, + para->dialIdx.callType); +#endif + + if ((aci_response== AT_FAIL) OR (aci_response== AT_BUSY)) + { + call_stat = MFW_CALL_FREE; + return cm_error_code(AT_CMD_D); + } + + return CM_OK; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_mo_call | ++--------------------------------------------------------------------+ + + + PURPOSE : start mobile originated call + +*/ + +T_MFW cm_mo_call(UBYTE *number, T_MFW_CM_CALL_TYPE type) +{ + CHAR * rest; + T_KSD_SEQPARAM para; + T_MFW_SS_RETURN typ; + T_MFW_SS_RETURN new_typ; + CHAR * string; + UBYTE cm_grp = 0; // RAVI + /*a0393213 compiler warning removal -- removed clir_status def*/ + UBYTE colr_status; + UBYTE prefix; + SHORT id; + T_ACI_RETURN res,aci_result;//aci_result was added to fix the bug MMI-SPR 16545 +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +// Fix: If flag FF_MMI_PB_OPTIM is defined then allocate memory for buf, phone and num_save variables +// through heap instead of stack. +#ifdef FF_MMI_PB_OPTIM + char * buf = (char*)mfwAlloc(80); + char * phone = (char*)mfwAlloc(MFW_NUM_LEN); + char * num_save = (char*)mfwAlloc(MFW_STRING_LEN); +#else + char buf[80]; + UBYTE phone[MFW_NUM_LEN]; + UBYTE num_save[MFW_STRING_LEN]; +#endif + + TRACE_FUNCTION ("cm_mo_call()"); + +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +#ifdef FF_MMI_PB_OPTIM + memset(buf,0,80); + memset(phone,0,MFW_NUM_LEN); + memset(num_save,0,MFW_STRING_LEN); + strncpy(num_save, (char *)number, MFW_STRING_LEN-1); +#else + strncpy((char *)num_save, (char *)number, MFW_STRING_LEN-1); + num_save[MFW_STRING_LEN-1] = 0; +#endif +// Oct 10, 2006 DR: OMAPS00093720 x0039928 +// Fix: Set ton to MFW_TON_INTERNATIONAL + if(number[0] EQ '+') + { + out_call.ton = MFW_TON_INTERNATIONAL; + } +else + { + out_call.ton = MFW_TON_UNKNOWN; + } + /* check the type of number (key sequence), current no function */ + typ = ss_decode(number, &rest, ¶); + TRACE_EVENT_P1("Type: %d", typ); + if (typ == MFW_SS_DIAL) + { + mfwStrncpy((char *)phone, para.dial.number, MFW_NUM_LEN); + + } + + if (typ == MFW_SS_HOLD) + { + cm_set_cmd_status(para.chld.mode, para.chld.call); + + // Feb 27, 2006 REF:DR OMAPS00067884 x0039928 + // Fix : sAT_PercentCHLD() is called if the mode > CHLD_MOD_RelDialCall + if(para.chld.mode > CHLD_MOD_RelDialCall) + aci_result = sAT_PercentCHLD(CMD_SRC_LCL, para.chld.mode, para.chld.call); + else + aci_result = sAT_PlusCHLD(CMD_SRC_LCL, para.chld.mode, para.chld.call); + + // Apr 26, 2004 REF: CRR 16545 Ajith K P + // If sAT_PlusCHLD() Fails, Send the user entered string as USSD to network using sAT-Dn(). + // So if its not failed just return CM_CTRL_STR, otherwise call sAT_Dn(). + if ( (aci_result EQ AT_CMPL ) OR (aci_result EQ AT_EXCT ) OR (aci_result EQ AT_BUSY )) + { +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +// Fix: Free the memory allocated for buf, phone and num_save variables +#ifdef FF_MMI_PB_OPTIM + if(buf) + mfwFree((U8*) buf,80); + if(phone) + mfwFree((U8*) phone,MFW_NUM_LEN); + if(num_save) + mfwFree((U8*) num_save,MFW_STRING_LEN); +#endif + return CM_CTRL_STR; + } + } + //MC 11.04.02 + if (typ == MFW_SS_ECT) + { + cm_set_cmd_status(para.chld.mode, para.chld.call); + if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_Ect, 0) != AT_EXCT) + { + //Aug 10, 2005 REF: MMI-SPR-30099 x0018858 + //commented this return value. + // return CM_ERROR; + } + else + { +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +// Fix: Free the memory allocated for buf,phone and num_save variables + #ifdef FF_MMI_PB_OPTIM + if(buf) + mfwFree((U8*) buf,80); + if(phone) + mfwFree((U8*) phone,MFW_NUM_LEN); + if(num_save) + mfwFree((U8*) num_save,MFW_STRING_LEN); + #endif + return CM_CTRL_STR; + } + } + //MC + + if (typ == MFW_SS_DIAL_IDX) + { +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +// Fix: Free the memory allocated for buf,phone and num_save variables + #ifdef FF_MMI_PB_OPTIM + if(buf) + mfwFree((U8*) buf,80); + if(phone) + mfwFree((U8*) phone,MFW_NUM_LEN); + if(num_save) + mfwFree((U8*) num_save,MFW_STRING_LEN); + #endif + return cm_mo_idx(¶, type); + } + + switch (typ) + { + +//NM + case MFW_SS_CLIR: //jgg wrong not CM_OK should be CM_SS, however cm_grp not used after funtion callnumber called + + case MFW_SS_DIAL: + cm_grp = CM_OK; + break; + + case MFW_SS_DTMF: + case MFW_SS_CF: + case MFW_SS_CB: + case MFW_SS_CLIP: + case MFW_SS_COLR: + case MFW_SS_COLP: + case MFW_SS_WAIT: + case MFW_SS_HOLD: + case MFW_SS_CCBS: + case MFW_SS_REG_PW: +//Aug 10, 2005 REF: MMI-SPR-30099 x0018858 +//Added this case statement. + case MFW_SS_ECT: + cm_grp = CM_SS; + break; + + case MFW_SS_USSD: + cm_grp = CM_USSD; + break; + + case MFW_SS_SIM_LOCK: + case MFW_SS_SIM_REG_PW: + case MFW_SS_SIM_UNBLCK_PIN: + cm_grp = CM_SIM; + break; + + case MFW_SS_MMI: + cm_grp = CM_MMI; + break; + +/* SPR#1352 - SH - TTY + * If an SS string has been entered, temporarily enable or disable + * TTY for this call only. */ + + case MFW_SS_TTY_NEXTCALL_ON: + case MFW_SS_TTY_NEXTCALL_OFF: + { + if (typ==MFW_SS_TTY_NEXTCALL_ON) + { + cm_tty_enable(TRUE); + } + else + { + cm_tty_enable(FALSE); + } +// Sep 01, 2006 REF:OMAPS00090555 x0039928 + #ifdef FF_MMI_PB_OPTIM + strcpy(num_save, (num_save + 4)); /* Ignore SS string when dialling */ + #else + strcpy((char *)num_save, (char *)&num_save[4]); /* Ignore SS string when dialling */ + #endif + rest = (char *)&number[4]; /* Look at number following SS string */ + } + break; +/* SH end */ + + default: +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +// Fix: Free the memory allocated for buf,phone and num_save variables + #ifdef FF_MMI_PB_OPTIM + if(buf) + mfwFree((U8*) buf,80); + if(phone) + mfwFree((U8*) phone,MFW_NUM_LEN); + if(num_save) + mfwFree((U8*) num_save,MFW_STRING_LEN); + #endif + return CM_ERROR; + } + + string = rest; + + colr_status = 0; +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +#ifndef FF_MMI_PB_OPTIM + buf[0] = '\0'; +#endif + cc_stat.prefix[0] = '\0'; + while(strlen(string)) + { + TRACE_EVENT("In the while"); + new_typ = ss_decode((UBYTE *)string, &rest, ¶); +// /* + if (new_typ == MFW_SS_CLIR) + { + + if (para.Clir.mode == CLIR_MOD_Supp) + { + strcat((char *)cc_stat.prefix, "*31#"); + TRACE_EVENT ("CLIR_MOD_Supp"); + } + if (para.Clir.mode == CLIR_MOD_Invoc) + { + strcat((char *)cc_stat.prefix, "#31#"); + TRACE_EVENT ("CLIR_MOD_Invoc"); + } + } + if (new_typ == MFW_SS_COLR) + colr_status = 1; + if (new_typ == MFW_SS_DIAL) + { + TRACE_EVENT("It's a dial"); + /* SPR#1352 - SH - only copy string to dial, not whole string */ + if (typ==MFW_SS_TTY_NEXTCALL_ON || typ==MFW_SS_TTY_NEXTCALL_OFF) + { + typ = new_typ; + TRACE_EVENT_P1("phone now holds: %s", phone); + } + else + /* end SH */ + { + typ = new_typ; + mfwStrncpy((char *)phone, para.dial.number, MFW_NUM_LEN); + } + } + string = rest; + } + + if (!colr_status AND (typ == MFW_SS_DIAL)) + { + prefix = cli_prefix & 0xc0; + if (prefix == 0x80) + { + strcat(buf, "*77#"); + strcat((char *)cc_stat.prefix, "*77#"); + } + if (prefix == 0xc0) + { + strcat(buf, "#77#"); + strcat((char *)cc_stat.prefix, "#77#"); + } + } + + if (typ == MFW_SS_DIAL) + { + res = (T_ACI_RETURN)cm_check_mo_number((UBYTE*)phone); /*a0393213 lint warnings removal - typecast done*/ + if ( res != CM_OK) + { +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +// Fix: Free the memory allocated for buf,phone and num_save variables + #ifdef FF_MMI_PB_OPTIM + if(buf) + mfwFree((U8*) buf,80); + if(phone) + mfwFree((U8*) phone,MFW_NUM_LEN); + if(num_save) + mfwFree((U8*) num_save,MFW_STRING_LEN); + #endif + return res; + } + + /* set the outgoing call status */ + call_stat = OUTGOING_CALL; + redial_count = 0; + cc_stat.type = OUTGOING_CALL; + cm_grp = CM_OK; + currConnecting = 1; + cm_set_call_mode(type); + } + + strcat(buf, (char *)num_save); + if (cm_search_callId(CAL_STAT_Active, &id) EQ CM_OK) + { + /* + * at least one active, this must be put on hold + * by ACI first, then dial + */ + cm_set_cmd_status(CHLD_MOD_HldActDial, ""); +#ifdef MMI_LINT_WARNING_REMOVAL /*a0393213 lint warnings removal*/ + cc_id = id; +#endif + } + if (type == DATA_CALL) + para.dial.callType = D_TOC_Data; + +// Apr 22, 2004 REF: CRR MMI-SPR-16873 Rashmi C N(Sasken) +// Using the CLIR status maintained in the flash, while making a call + if (!FFS_flashData.CLIR) + { + res = sAT_Dn(CMD_SRC_LCL, buf, D_CLIR_OVRD_Supp, D_CUG_CTRL_NotPresent, para.dial.callType); /*a0393213 compiler warning removal-- -1 changed to D_CUG_CTRL_NotPresent*/ + } + else + { + res = sAT_Dn(CMD_SRC_LCL, buf, D_CLIR_OVRD_Invoc, D_CUG_CTRL_NotPresent, para.dial.callType); /*a0393213 compiler warning removal-- -1 changed to D_CUG_CTRL_NotPresent*/ + } + + if ((res == AT_FAIL) OR (res == AT_BUSY)) + { +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +// Fix: Free the memory allocated for buf,phone and num_save variables + #ifdef FF_MMI_PB_OPTIM + if(buf) + mfwFree((U8*) buf,80); + if(phone) + mfwFree((U8*) phone,MFW_NUM_LEN); + if(num_save) + mfwFree((U8*) num_save,MFW_STRING_LEN); + #endif + if (typ == MFW_SS_CLIP) + return CM_CLI; + + call_stat = MFW_CALL_FREE; + return cm_error_code(AT_CMD_D); + } + if (res == AT_CMPL) + { + switch (typ) + { + case MFW_SS_CLIR: + case MFW_SS_CLIP: + case MFW_SS_COLR: + case MFW_SS_COLP: +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +// Fix: Free the memory allocated for buf,phone and num_save variables + #ifdef FF_MMI_PB_OPTIM + if(buf) + mfwFree((U8*) buf,80); + if(phone) + mfwFree((U8*) phone,MFW_NUM_LEN); + if(num_save) + mfwFree((U8*) num_save,MFW_STRING_LEN); + #endif + return CM_CLI; + default: + break; + } + } +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +// Fix: Free the memory allocated for buf,phone and num_save variables + #ifdef FF_MMI_PB_OPTIM + if(buf) + mfwFree((U8*) buf,80); + if(phone) + mfwFree((U8*) phone,MFW_NUM_LEN); + if(num_save) + mfwFree((U8*) num_save,MFW_STRING_LEN); + #endif + return cm_grp; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: GSM-MFW (8417) MODULE: MFW_CB | +| STATE : code ROUTINE: rAT_PlusCRING_OFF | ++--------------------------------------------------------------------+ + + + PURPOSE : Alert Off indication from ACI + +*/ + +#ifdef FF_2TO1_PS +GLOBAL void rAT_PlusCRING_OFF ( SHORT cId ) +{ + T_MFW_CM_CALL_STAT stat; + UBYTE ton; + T_CAUSE_ps_cause report; /* Marcus: Extended error reporting: 12/11/2002 */ + UBYTE mode; + + TRACE_FUNCTION ("rAT_PlusCRING_OFF()"); + + if (cm_search_callStat(cId, &stat, &ton, &mode) == CM_OK) + { + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + + //TISH: if there is inband tone, it should not disconnect the call. OMAPS00104986 + if (stat == CALL_DEACTIVE && !cm_cpi.inband) + // if (stat == CALL_DEACTIVE) + { + dis_connect.call_number = cId; + + qAT_PlusCEER( CMD_SRC_LCL, &report); + /* Marcus: Extended error reporting: 12/11/2002: Start */ + +// TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report); + if (report.ctrl_value != CAUSE_is_from_nwcc) + { + /* Treat Condat defined cause values as if no cause given */ + dis_connect.cause = NOT_PRESENT_8BIT; + } + else + { + /* Standards defined cause value is given */ + dis_connect.cause = report.value.nwcc_cause; + } + TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause); + /* Marcus: Extended error reporting: 12/11/2002: End */ + cm_signal(E_CM_DISCONNECT, &dis_connect); + return; + } + cm_signal(E_CM_RING_OFF, 0); + } +} +#else +GLOBAL void rAT_PlusCRING_OFF ( SHORT cId ) +{ + T_MFW_CM_CALL_STAT stat; + UBYTE ton; + USHORT report; /* Marcus: Extended error reporting: 12/11/2002 */ + UBYTE mode; + + TRACE_FUNCTION ("rAT_PlusCRING_OFF()"); + + if (cm_search_callStat(cId, &stat, &ton, &mode) == CM_OK) + { + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + + //TISH: if there is inband tone, it should not disconnect the call. OMAPS00104986 + if (stat == CALL_DEACTIVE && !cm_cpi.inband) + // if (stat == CALL_DEACTIVE) + { + dis_connect.call_number = cId; + + qAT_PlusCEER( CMD_SRC_LCL, &report); + /* Marcus: Extended error reporting: 12/11/2002: Start */ + TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report); + if (GET_CAUSE_DEFBY(report) == DEFBY_CONDAT) + { + /* Treat Condat defined cause values as if no cause given */ + dis_connect.cause = NOT_PRESENT_8BIT; + } + else + { + /* Standards defined cause value is given */ + dis_connect.cause = GET_CAUSE_VALUE(report); + } + TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause); + /* Marcus: Extended error reporting: 12/11/2002: End */ + cm_signal(E_CM_DISCONNECT, &dis_connect); + return; + } + cm_signal(E_CM_RING_OFF, 0); + } +} +#endif + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : rAT_PlusCRING | ++--------------------------------------------------------------------+ + + + PURPOSE : Alert indication from ACI + +*/ +/*a0393213 warnings removal - second and third parameter changed as a result of ACI enum change*/ +void rAT_PlusCRING(T_ACI_CRING_MOD mode, + T_ACI_CRING_SERV_TYP type1, + T_ACI_CRING_SERV_TYP type2) +{ + SHORT call_number; + + TRACE_FUNCTION ("rAT_PlusCRING()"); + + in_call.result = Present; + + /* search the call identifier */ + if (cm_search_callId(CAL_STAT_Wait, &call_number) == CM_OK) + in_call.call_number = call_number; + else + in_call.call_number = 0; + + /* If redial is active, it must be stoped. */ + if (call_stat == REDIALING_CALL) + { + cm_stop_redialTim(); + rdl.redial_mode = CM_REDIAL_INCOMING; + cm_signal(E_CM_REDIAL, &rdl); + } + + if (mode EQ CRING_MOD_Direct) + { + switch (type1) + { + /* Voice call */ + case CRING_SERV_TYP_Voice: + if (type2 EQ CRING_SERV_TYP_NotPresent) + { + in_call.type = VOICE_CALL; + cm_set_call_mode(VOICE_CALL); + } + else + { + switch (type2) + { + case CRING_SERV_TYP_Sync: + case CRING_SERV_TYP_Async: + case CRING_SERV_TYP_RelSync: + case CRING_SERV_TYP_RelAsync: + in_call.type = VFD_VOICE; + cm_bc_parameter(type2); + cm_set_call_mode(VFD_VOICE); + break; + /*MC, SPR 1026, check for line1 and line2*/ + case CRING_SERV_TYP_Voice: + in_call.type = VOICE_CALL; + cm_set_call_mode(VOICE_CALL); + break; + case CRING_SERV_TYP_AuxVoice: + cm_set_call_mode(AuxVOICE_CALL); + in_call.type = AuxVOICE_CALL; + break; + /*MC, end*/ + default: + in_call.type = VOICE_CALL; + cm_set_call_mode(VOICE_CALL); + break; + } + } + break; + /*MC, SPR 1026, Added case of Type1=CRING_SERV_TYP_AuxVoice*/ + /*assuming line 2 is handled like line 1*/ + case CRING_SERV_TYP_AuxVoice: + if (type2 EQ CRING_SERV_TYP_NotPresent) + { + in_call.type = AuxVOICE_CALL; + cm_set_call_mode(AuxVOICE_CALL); + } + else + { + switch (type2) + { + case CRING_SERV_TYP_Sync: + case CRING_SERV_TYP_Async: + case CRING_SERV_TYP_RelSync: + case CRING_SERV_TYP_RelAsync: + in_call.type = VFD_VOICE; + cm_bc_parameter(type2); + cm_set_call_mode(VFD_VOICE); + break; + case CRING_SERV_TYP_Voice: + in_call.type = VOICE_CALL; + cm_set_call_mode(VOICE_CALL); + break; + case CRING_SERV_TYP_AuxVoice: + cm_set_call_mode(AuxVOICE_CALL); + in_call.type = AuxVOICE_CALL; + break; + default: + in_call.type = VOICE_CALL; + cm_set_call_mode(VOICE_CALL); + break; + } + } + break; + /*MC, end*/ + /* Data call */ + case CRING_SERV_TYP_Sync: + case CRING_SERV_TYP_Async: + case CRING_SERV_TYP_RelSync: + case CRING_SERV_TYP_RelAsync: + in_call.type = DATA_CALL; + cm_bc_parameter(type1); + cm_set_call_mode(DATA_CALL); + break; + + case CRING_SERV_TYP_Fax: + in_call.type = FAX_CALL; + in_call.bc1.conn_elem = Transparent; + cm_set_call_mode(FAX_CALL); + break; + + default: + in_call.result = NotPresent; + break; + } + call_stat = INCOMING_CALL; + } + + if (mode EQ CRING_MOD_Alternate) + { + cm_build_callType(type1, type2); + cm_bc_parameter(type1); + cm_bc_parameter(type2); + cm_set_call_mode(in_call.type); + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: rAT_PlusCLIP | ++--------------------------------------------------------------------+ + + + PURPOSE : The calling line identification for an incomming call. + +*/ + +#ifdef NO_ASCIIZ +void rAT_PlusCLIP(T_ACI_CLIP_STAT stat, + CHAR * number, + T_ACI_TOA * type, + U8 validity, + CHAR * subaddr, + T_ACI_TOS * satype, + T_ACI_PB_TEXT * alpha) +{ + int flag; + + TRACE_FUNCTION ("rAT_PlusCLIP()"); + + flag = 0; + + if (number != NULL) + { + mfwStrncpy((char *)in_call.number, (char *)number, MFW_NUM_LEN); + in_call.ton = phb_cvtTon(type->ton); + flag = 1; + } + else + memset(in_call.number, '\0', MFW_NUM_LEN); + + if (alpha != NULL) + { + in_call.name.len = alpha->len; + if (alpha->len) + { + memcpy(in_call.name.data, + alpha->data, + alpha->len); + flag = 1; + } + } + else + in_call.name.len = 0; + + + if (subaddr != NULL) + { + mfwStrncpy((char *)in_call.subaddr, (char *)subaddr, MFW_SUBADR_LEN); + flag = 1; + } + else + memset(in_call.subaddr, '\0', MFW_SUBADR_LEN); + + if (flag == 1) + in_call.result = Present; + else + in_call.result = 0; + + cm_signal(E_CM_CW, &in_call); +} + +#else + +void rAT_PlusCLIP(T_ACI_CLIP_STAT stat, + CHAR * number, + T_ACI_TOA * type, + U8 validity, + CHAR * subaddr, + T_ACI_TOS * satype, + CHAR * alpha) +{ + int flag; + + TRACE_FUNCTION ("rAT_PlusCLIP()"); + + flag = 0; +// in_call.result = 0; + + if (number != NULL) + { + mfwStrncpy((char *)in_call.number, (char *)number, MFW_NUM_LEN); + in_call.ton = phb_cvtTon(type->ton); + flag = 1; + } + else + memset(in_call.number, '\0', MFW_NUM_LEN); + + if (alpha != NULL) + { + mfwStrncpy((char *)in_call.name, (char *)alpha, MFW_TAG_LEN); + flag = 1; + } + else + memset(in_call.name, '\0', MFW_TAG_LEN); + + if (subaddr != NULL) + { + mfwStrncpy((char *)in_call.subaddr, (char *)subaddr, MFW_SUBADR_LEN); + flag = 1; + } + else + memset(in_call.subaddr, '\0', MFW_SUBADR_LEN); + + if (flag == 1) + in_call.result = Present; + else + in_call.result = 0; + + cm_signal(E_CM_CW, &in_call); +} +#endif + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-MFW (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : rAT_PlusCOLP | ++--------------------------------------------------------------------+ + + + PURPOSE : Connected line presentation indication from ACI + +*/ + +#ifdef NO_ASCIIZ +GLOBAL void rAT_PlusCOLP ( T_ACI_COLP_STAT stat, + CHAR* number, + T_ACI_TOA* type, + CHAR* subaddr, + T_ACI_TOS* satype, + T_ACI_PB_TEXT* alpha) +{ + + TRACE_FUNCTION ("rAT_PlusCOLP()"); + + if (number != NULL) + { + mfwStrncpy((char *)out_call.number, (char *)number, MFW_NUM_LEN); + out_call.ton = phb_cvtTon(type->ton); + } + else + memset(out_call.number, '\0', MFW_NUM_LEN); + + /*NM, p001 */ + if(alpha != NULL) + /*NM, p001 end */ + { + out_call.name.len = MINIMUM(alpha->len, MFW_TAG_LEN); + if (alpha->len) + memcpy(out_call.name.data, + alpha->data, + alpha->len); + } + + if (subaddr != NULL) + mfwStrncpy((char *)out_call.subaddr, (char *)subaddr, MFW_SUBADR_LEN); + else + memset(out_call.subaddr, '\0', MFW_SUBADR_LEN); + + if (number != NULL) + cm_signal(E_CM_COLP, &out_call); +} + +#else + +GLOBAL void rAT_PlusCOLP ( T_ACI_COLP_STAT stat, + CHAR* number, + T_ACI_TOA* type, + CHAR* subaddr, + T_ACI_TOS* satype, + CHAR* alpha) +{ + TRACE_FUNCTION ("rAT_PlusCOLP()"); + +// patch PMA 15 06 99 from Andreas +// if (stat == -1) +// return; + + if (number != NULL) + { + mfwStrncpy((char *)out_call.number, (char *)number, MFW_NUM_LEN); + out_call.ton = phb_cvtTon(type->ton); + } + else + memset(out_call.number, '\0', MFW_NUM_LEN); + + if (alpha != NULL) + mfwStrncpy((char *)out_call.name, (char *)alpha, MFW_TAG_LEN); + else + memset(out_call.name, '\0', MFW_TAG_LEN); + + if (subaddr != NULL) + mfwStrncpy((char *)out_call.subaddr, (char *)subaddr, MFW_SUBADR_LEN); + else + memset(out_call.subaddr, '\0', MFW_SUBADR_LEN); + +// patch PMA 15 06 99 from Andreas + if (number != NULL) + cm_signal(E_CM_COLP, &out_call); +} +#endif + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-MFW (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : rAT_PlusCCWA | ++--------------------------------------------------------------------+ + + + PURPOSE : Connected line presentation indication from ACI + +*/ + +#ifdef NO_ASCIIZ + +GLOBAL void rAT_PlusCCWA ( T_ACI_CLSSTAT * clsStatLst, + CHAR * number, + T_ACI_TOA * type, + U8 validity, + T_ACI_CLASS call_class, + T_ACI_PB_TEXT * alpha) +{ + SHORT call_number; + + TRACE_FUNCTION("rAT_PlusCCWA()"); + + in_call.result = NotPresent; + if (clsStatLst == 0) + { + if (number != NULL) + { + mfwStrncpy((char *)in_call.number, (char *)number, MFW_NUM_LEN); + in_call.ton = phb_cvtTon(type->ton); + } + else + memset(in_call.number, '\0', MFW_NUM_LEN); + + if (alpha != NULL) + in_call.name.len = alpha->len; + else + in_call.name.len = 0; + + if (in_call.name.len && alpha!=NULL) /*a0393213 lint warning removal - check for alpha done*/ + { + memcpy(in_call.name.data, + alpha->data, + alpha->len); + } + + in_call.type = cm_callTyp_cvt(call_class); + + if (number != 0 || in_call.name.len != 0 || in_call.type != NONE_TYPE) + in_call.result = Present; + + cm_search_callId(CAL_STAT_Wait, &call_number); + in_call.call_number = call_number; + + cm_signal(E_CM_CW, &in_call); + } +} + +#else + +GLOBAL void rAT_PlusCCWA ( T_ACI_CLSSTAT * clsStatLst, + CHAR * number, + T_ACI_TOA * type, + U8 validity, + T_ACI_CLASS call_class, + CHAR * alpha) +{ + SHORT call_number; + + in_call.result = NotPresent; + if (clsStatLst == 0) + { + if (number != NULL) + { + mfwStrncpy((char *)in_call.number, (char *)number, MFW_NUM_LEN); + in_call.ton = phb_cvtTon(type->ton); + } + else + memset(in_call.number, '\0', MFW_NUM_LEN); + + if (alpha != NULL) + mfwStrncpy((char *)in_call.name, (char *)alpha, MFW_TAG_LEN); + else + memset(in_call.name, '\0', MFW_TAG_LEN); + + in_call.type = cm_callTyp_cvt(call_class); + + if (number != 0 || alpha != 0 || in_call.type != NONE_TYPE) + in_call.result = Present; + + cm_search_callId(CAL_STAT_Wait, &call_number); + in_call.call_number = call_number; + + cm_signal(E_CM_CW, &in_call); + } +} +#endif + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_mt_reject | ++--------------------------------------------------------------------+ + + + PURPOSE : Reject the incoming call. + +*/ + +void cm_mt_reject() +{ + TRACE_FUNCTION ("cm_mt_reject()"); + + if (currAccepting) + { + currAccepting = 0; /* ES!! 210999 */ + sAT_Abort(CMD_SRC_LCL, AT_CMD_A); + return; + } + + cmd_hold = MFW_CM_MT_REJECT; + cm_search_callId(CAL_STAT_Wait, &dis_connect.call_number); + sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelHldOrUdub, 0); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_mt_accept | ++--------------------------------------------------------------------+ + + + PURPOSE : Accept the incoming call. If the active call exists, + place this active call on hold and accepts the + waiting call. + +*/ + +void cm_mt_accept() +{ + SHORT call_number; + T_MFW_CM_CALL_STAT stat; /* SPR#1983 - SH */ + UBYTE ton; + UBYTE mode; + + TRACE_FUNCTION ("cm_mt_accept()"); + + if (cm_search_callId(CAL_STAT_Active, &call_number) != CM_OK) + { + if (sAT_A(CMD_SRC_LCL) NEQ AT_EXCT) + { + TRACE_ERROR("sAT_A error"); + } + else + { + currAccepting = 1; /* ES!! 210999 */ + } + } + else + { + cmd_hold = MFW_CM_MT_ACCEPT; + + /* SPR#1983 - SH - Get status of active call */ + + cm_search_callStat(call_number, &stat, &ton, &mode); +#ifdef MMI_LINT_WARNING_REMOVAL /*a0393213 lint warnings removal*/ + if (cm_search_callId(CAL_STAT_Wait, &call_number) EQ CM_OK) + cc_id = call_number; +#else + cm_search_callId(CAL_STAT_Wait, &call_number); +#endif + /* SPR#1983 - SH - If data call is active, end it and accept other call */ + + if (mode==DATA_CALL) + { + /* + * Accepting a call when there is an active data call, + * so drop the active call and accept the waiting call by the + * equivalent of the AT+CHLD=1 command. + */ + cm_set_cmd_status(CHLD_MOD_RelActAndAcpt, ""); + if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActAndAcpt, 0) NEQ AT_EXCT) + { + TRACE_ERROR("sAT_PlusCHLD(CHLD_MOD_RelActAndAcpt) error"); + } + } + + else /* SPR#1983 - SH - Important! Acts on next 'if' */ + + /* Marcus: issue 1049: 03/09/2002: Start */ + if (cm_search_callId(CAL_STAT_Held, &call_number) EQ CM_OK) + { + /* + * Accepting a call when there is already an active call and a held + * call, so drop the active call and accept the waiting call by the + * equivalent of the AT+CHLD=1 command. + */ + cm_set_cmd_status(CHLD_MOD_RelActAndAcpt, ""); + if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActAndAcpt, 0) NEQ AT_EXCT) + { + TRACE_ERROR("sAT_PlusCHLD(CHLD_MOD_RelActAndAcpt) error"); + } + } + else + { + /* + * Accepting a call when there is already an active call but no held + * call, so hold the active call and accept the waiting call by the + * equivalent of the AT+CHLD=2 command. + */ + cm_set_cmd_status(CHLD_MOD_HldActAndAcpt, ""); + if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_HldActAndAcpt, 0) NEQ AT_EXCT) + { + TRACE_ERROR("sAT_PlusCHLD(CHLD_MOD_HldActAndAcpt) error"); + } + } + /* Marcus: issue 1049: 03/09/2002: End */ + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_end_all | ++--------------------------------------------------------------------+ + + + PURPOSE : End all calls (Held and Active) + +*/ + +void cm_end_all(void) +{ + T_ACI_RETURN aci_res; // The value returned by sAT_H + + TRACE_EVENT("cm_end_all()"); + + aci_res = sAT_H(CMD_SRC_LCL); + + if (aci_res == AT_EXCT) + { + TRACE_EVENT("sAT_H returned AT_EXCT"); + cmd_hold = MFW_CM_DISCONNECT_ALL; + } + else + { + TRACE_EVENT_P1("sAT_H returned %d", aci_res); + } + return; +} + + + +// Apr 26 2006, a0393213 (Prabakar R), OMAPS00074886 : No option in MMI to release the held call. +// This function is added to release all held calls + +/******************************************************************************* + + $Function: cm_end_held + + $Description: End held calls + + $Returns: void + + $Arguments: void + +*******************************************************************************/ + +void cm_end_held(void) +{ + T_ACI_RETURN aci_res; // The value returned by sAT_PlusCHLD + + TRACE_EVENT("cm_end_held()"); + + aci_res = sAT_PlusCHLD(CMD_SRC_LCL,CHLD_MOD_RelHldOrUdub,NULL); + + if (aci_res == AT_FAIL) + { + TRACE_EVENT("sAT_PlusCHLD returned AT_FAIL"); + } + + return; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_ok_connect | ++--------------------------------------------------------------------+ + + + PURPOSE : The connect is successful. + +*/ + +void cm_ok_connect(void) +{ + SHORT call_number; + + TRACE_FUNCTION ("cm_ok_connect()"); + + currAccepting = 0; /* ES!! 210999 */ + currConnecting = 0; /* ES!! 290999 */ + + if (cc_stat.type == REDIALING_CALL) + { + rdl.redial_mode = CM_REDIAL_SUCCESS; + cm_signal(E_CM_REDIAL, &rdl); + } + + cm_search_callId(CAL_STAT_Active, &call_number); + + /* allow a new outgoing */ + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cmd_hold = MFW_CM_NO_FLAG; + + cm_signal(E_CM_CONNECT_ACK, &call_number); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_rmt_ok_connect | ++--------------------------------------------------------------------+ + + + PURPOSE : The connect is successful. + +*/ + +void cm_rmt_ok_connect() +{ + SHORT call_number; + + TRACE_FUNCTION ("cm_rmt_ok_connect()"); + + cm_search_callId(CAL_STAT_Active, &call_number); + + cm_signal(E_CM_CONNECT_ACK, &call_number); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_error_connect | ++--------------------------------------------------------------------+ + + + PURPOSE : The connection is not successful + +*/ + +#ifdef FF_2TO1_PS +void cm_error_connect(SHORT call_number) +{ + int i; + T_CAUSE_ps_cause report; /* Marcus: Extended error reporting: 12/11/2002 */ + USHORT extend_report; /* API - 1564 - 16-01-03 - add this variable to store the new error code */ + + TRACE_FUNCTION ("cm_error_connect()"); + + currAccepting = 0; /* ES!! 210999 */ + currConnecting = 0; /* ES!! 290999 */ + + /* send event */ + dis_connect.call_number = call_number; + + qAT_PlusCEER( CMD_SRC_LCL, &report); + /* Marcus: Extended error reporting: 12/11/2002: Start */ +// TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report); + + /* API - 1564 - 16-01-03 - store the error value to the new variable & throughout this function replace 'report' with 'extend_report */ + extend_report = report.value.nwcc_cause; + + if (report.ctrl_value != CAUSE_is_from_nwcc) + { + /* Treat Condat defined cause values as if no cause given */ + dis_connect.cause = NOT_PRESENT_8BIT; + } + else + { + /* Standards defined cause value is given */ + dis_connect.cause = report.value.nwcc_cause; + } + TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause); + /* Marcus: Extended error reporting: 12/11/2002: End */ + cm_signal(E_CM_DISCONNECT, &dis_connect); + TRACE_EVENT("passed the E_CM_DISCONNECT point"); + + if ((call_stat EQ OUTGOING_CALL) + AND (call_type NEQ MFW_ECC_CALL) + AND ((redial_stat EQ CM_REDIAL_AUTO) OR (redial_stat EQ CM_REDIAL_MANU))) + { + /* If this call is 2nd outgoing call, redial is not started */ + if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) EQ AT_CMPL) + { + for (i=0; i<MAX_CALL_NR; i++) + { + if (call_tab[i].index == -1) + break; + + if ((call_tab[i].status == CAL_STAT_NotPresent) + OR (call_tab[i].status == CAL_STAT_DeactiveReq)) + continue; + + if (call_tab[i].calType == CAL_TYPE_MOC) + { + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cmd_hold = MFW_CM_NO_FLAG; + return; + } + } + } + + /* check blacklist whether it is full */ + if (black_list.count == MAX_BLACKLIST_NUM) + { + TRACE_EVENT ("blacklist is now full"); + + /* Blacklist is now full and + MT shall prohibit further automatic call attempts + */ + redial_stat = CM_REDIAL_OFF; + + + /* allow a new outgoing */ + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cc_stat.type = MFW_CALL_FREE; + + rdl.redial_mode = CM_REDIAL_BLACKLIST; + cm_signal(E_CM_REDIAL, &rdl); + return; + } + + /* check the registration staus */ + if (nm_reg_status() == MFW_NO_SERVICE) + { + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cc_stat.type = MFW_CALL_FREE; + + rdl.redial_mode = CM_REDIAL_NO_SERVICE; + cm_signal(E_CM_REDIAL, &rdl); + return; + } + + TRACE_EVENT_P1("report = %d", extend_report); + switch (extend_report) + { + case 28: + // API - 1480 - Added this code to stop redial on an incorrect number + if(!redial_count) + { + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cc_stat.type = MFW_CALL_FREE; + + rdl.redial_mode = CM_REDIAL_ABORTED; + cm_signal(E_CM_REDIAL, &rdl); + return; + } + case 1: /* check whether the reason is in category 3 (GSM 02.07) */ + case 3: + case 22: + case 38: + TRACE_EVENT ("category 3"); + if (!redial_count) + { + /* redial_count == 0; + this is for the first outgoing call and + now it is going to start the Auto-redial procedure + */ + cc_stat.type = REDIALING_CALL; + cc_stat.call_number = 0; + + call_stat = REDIALING_CALL; + rdl.redial_mode = CM_REDIAL_STARTED; + mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN); + +#ifdef NO_ASCIIZ + rdl.name.len = cc_stat.name.len; + memcpy(rdl.name.data, + cc_stat.name.data, + cc_stat.name.len); +#else + mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN); +// strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr); +#endif + rdl.ton = cc_stat.ton; + rdl.type = cc_stat.mode; + + /* reasons in the category 3 have + a call repeat attempts of max. 1 ! + */ + redial_count = MAX_REDIAL_ATTEMPT-1; + cm_signal(E_CM_REDIAL, &rdl); + return; + } + else + redial_count = MAX_REDIAL_ATTEMPT; + break; + + case 17: /* check whether the reason is in category 1 and 2 (GSM 02.07) */ + case 18: + case 19: + case 27: + case 34: + case 41: + case 42: + case 44: + case 47: + TRACE_EVENT ("category 1 & 2"); + if (!redial_count) + { + /* redial_count == 0 + this is for the first outgoing call and + now it is going to start the Auto-redial procedure + */ + cc_stat.type = REDIALING_CALL; + cc_stat.call_number = 0; + + call_stat = REDIALING_CALL; + rdl.redial_mode = CM_REDIAL_STARTED; + mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN); +#ifdef NO_ASCIIZ + rdl.name.len = cc_stat.name.len; + memcpy(rdl.name.data, + cc_stat.name.data, + cc_stat.name.len); +#else + mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN); +// strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr); +#endif + rdl.ton = cc_stat.ton; + rdl.type = cc_stat.mode; + + /* reasons in the category 1 and 2 have + a call repeat attempts of max. 10 ! + */ + + cm_signal(E_CM_REDIAL, &rdl); + return; + } + + if (redial_count >= 1 AND redial_count <= 3) + { + timStart(redialTim24); + call_stat = REDIALING_CALL; + cc_stat.call_number = 0; + return; + } + + if (redial_count >= 4 AND redial_count < MAX_REDIAL_ATTEMPT) + { + timStart(redialTim5); + call_stat = REDIALING_CALL; + cc_stat.call_number = 0; + return; + } +#ifdef CUSTOMER_6366 + // JP PATCH The MMI needs to know if the 'error disconnect' has + // resulted in redial starting irrespective of whether this was a redial attempt or not + rdl.redial_mode = CM_REDIAL_STARTED; + cm_signal(E_CM_REDIAL, &rdl); + // END JP PATCH +#endif /* CUSTOMER_6366 */ + break; + + default: + if (redial_count) + { + rdl.redial_mode = CM_REDIAL_STOP; + mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN); +#ifdef NO_ASCIIZ + rdl.name.len = cc_stat.name.len; + memcpy(rdl.name.data, + cc_stat.name.data, + cc_stat.name.len); +#else + mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);//??? +// strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr); +#endif + rdl.ton = cc_stat.ton; + rdl.type = cc_stat.mode; + cm_signal(E_CM_REDIAL, &rdl); + } + /* allow a new outgoing */ + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cc_stat.type = MFW_CALL_FREE; + return; + } + + if (redial_count >= MAX_REDIAL_ATTEMPT + AND black_list.count < MAX_BLACKLIST_NUM) + { + mfwStrncpy((char *)black_list.number[black_list.count], + (char *)cc_stat.number, MFW_NUM_LEN); + black_list.count++; + + rdl.redial_mode = CM_REDIAL_BLACKLISTED; + mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN); +#ifdef NO_ASCIIZ + rdl.name.len = cc_stat.name.len; + memcpy(rdl.name.data, + cc_stat.name.data, + cc_stat.name.len); +#else + mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN); +// strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr); +#endif + rdl.ton = cc_stat.ton; + rdl.type = cc_stat.mode; + rdl.left_attempts = 0; + cc_stat.call_number = 0; + cm_signal(E_CM_REDIAL, &rdl); + } + } + + /* allow a new outgoing */ + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cc_stat.type = MFW_CALL_FREE; +} +#else +void cm_error_connect(SHORT call_number) +{ + + int i; + USHORT report; /* Marcus: Extended error reporting: 12/11/2002 */ + USHORT extend_report; /* API - 1564 - 16-01-03 - add this variable to store the new error code */ +// Apr 06 2005 REF: CRR 29989 xpradipg +// local definition +#ifdef FF_MMI_OPTIM + T_ACI_CAL_ENTR *call_tab;//[MAX_CALL_NR]; +#endif +// Apr 14, 2005 REF: CRR 29991 xpradipg +// local definition +#ifdef FF_MMI_OPTIM + UBYTE count=0; + UBYTE blackListNum[MFW_NUM_LEN]; + int32 file = 0; +#endif + TRACE_FUNCTION ("cm_error_connect()"); + + currAccepting = 0; /* ES!! 210999 */ + currConnecting = 0; /* ES!! 290999 */ + + /* send event */ + dis_connect.call_number = call_number; + + qAT_PlusCEER( CMD_SRC_LCL, &report); + /* Marcus: Extended error reporting: 12/11/2002: Start */ + TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report); + + /* API - 1564 - 16-01-03 - store the error value to the new variable & throughout this function replace 'report' with 'extend_report */ + extend_report = GET_CAUSE_VALUE(report); + + if (GET_CAUSE_DEFBY(extend_report) == DEFBY_CONDAT) + { + /* Treat Condat defined cause values as if no cause given */ + dis_connect.cause = NOT_PRESENT_8BIT; + } + else + { + /* Standards defined cause value is given */ + dis_connect.cause = GET_CAUSE_VALUE(extend_report); + } + TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause); + /* Marcus: Extended error reporting: 12/11/2002: End */ + cm_signal(E_CM_DISCONNECT, &dis_connect); + TRACE_EVENT("passed the E_CM_DISCONNECT point"); + + if ((call_stat EQ OUTGOING_CALL) + AND (call_type NEQ MFW_ECC_CALL) + AND ((redial_stat EQ CM_REDIAL_AUTO) OR (redial_stat EQ CM_REDIAL_MANU))) + { +// Apr 06 2005 REF: CRR 29989 xpradipg +// allocate memory +#ifdef FF_MMI_OPTIM + call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); + if( NULL == call_tab) + return; +#endif + /* If this call is 2nd outgoing call, redial is not started */ + if (qAT_PercentCAL(CMD_SRC_LCL, call_tab) EQ AT_CMPL) + { + for (i=0; i<MAX_CALL_NR; i++) + { + if (call_tab[i].index == -1) + break; + + if ((call_tab[i].status == CAL_STAT_NotPresent) + OR (call_tab[i].status == CAL_STAT_DeactiveReq)) + continue; + + if (call_tab[i].calType == CAL_TYPE_MOC) + { + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cmd_hold = MFW_CM_NO_FLAG; +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return; + } + } + } +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif +// Apr 14, 2005 REF: CRR 29991 xpradipg +// read the list into the variable +#ifdef FF_MMI_OPTIM + if((file = flash_MMI_blackList_open()) >= 0 ) + { + if(flash_MMI_blackList_read(file,(U8*)&count, 1,0) > 0) + { + if(count == MAX_BLACKLIST_NUM) +#else + /* check blacklist whether it is full */ + if (black_list.count == MAX_BLACKLIST_NUM) +#endif + { + TRACE_EVENT ("blacklist is now full"); + + /* Blacklist is now full and + MT shall prohibit further automatic call attempts + */ + redial_stat = CM_REDIAL_ABORTED; + + + /* allow a new outgoing */ + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cc_stat.type = MFW_CALL_FREE; + + rdl.redial_mode = CM_REDIAL_BLACKLIST; + cm_signal(E_CM_REDIAL, &rdl); +#ifdef FF_MMI_OPTIM + flash_MMI_blackList_close(file); +#endif + return; + } +#ifdef FF_MMI_OPTIM + } + flash_MMI_blackList_close(file); + } +#endif + + /* check the registration staus */ + if (nm_reg_status() == MFW_NO_SERVICE) + { + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cc_stat.type = MFW_CALL_FREE; + + rdl.redial_mode = CM_REDIAL_NO_SERVICE; + cm_signal(E_CM_REDIAL, &rdl); + return; + } + + TRACE_EVENT_P1("report = %d", extend_report); + switch (extend_report) + { + case 28: + // API - 1480 - Added this code to stop redial on an incorrect number + if(!redial_count) + { + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cc_stat.type = MFW_CALL_FREE; + + rdl.redial_mode = CM_REDIAL_ABORTED; + cm_signal(E_CM_REDIAL, &rdl); + return; + } + case 1: /* check whether the reason is in category 3 (GSM 02.07) */ + case 3: + case 22: + case 38: + TRACE_EVENT ("category 3"); + if (!redial_count) + { + /* redial_count == 0; + this is for the first outgoing call and + now it is going to start the Auto-redial procedure + */ + cc_stat.type = REDIALING_CALL; + cc_stat.call_number = 0; + + call_stat = REDIALING_CALL; + rdl.redial_mode = CM_REDIAL_STARTED; + mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN); + +#ifdef NO_ASCIIZ + rdl.name.len = cc_stat.name.len; + memcpy(rdl.name.data, + cc_stat.name.data, + cc_stat.name.len); +#else + mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN); +// strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr); +#endif + rdl.ton = cc_stat.ton; + rdl.type = cc_stat.mode; + + /* reasons in the category 3 have + a call repeat attempts of max. 1 ! + */ + redial_count = MAX_REDIAL_ATTEMPT-1; + cm_signal(E_CM_REDIAL, &rdl); + return; + } + else + redial_count = MAX_REDIAL_ATTEMPT; + break; + + case 17: /* check whether the reason is in category 1 and 2 (GSM 02.07) */ + case 18: + case 19: + case 27: + case 34: + case 41: + case 42: + case 44: + case 47: + TRACE_EVENT ("category 1 & 2"); + if (!redial_count) + { + /* redial_count == 0 + this is for the first outgoing call and + now it is going to start the Auto-redial procedure + */ + cc_stat.type = REDIALING_CALL; + cc_stat.call_number = 0; + + call_stat = REDIALING_CALL; + rdl.redial_mode = CM_REDIAL_STARTED; + mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN); +#ifdef NO_ASCIIZ + rdl.name.len = cc_stat.name.len; + memcpy(rdl.name.data, + cc_stat.name.data, + cc_stat.name.len); +#else + mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN); +// strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr); +#endif + rdl.ton = cc_stat.ton; + rdl.type = cc_stat.mode; + + /* reasons in the category 1 and 2 have + a call repeat attempts of max. 10 ! + */ + + cm_signal(E_CM_REDIAL, &rdl); + return; + } + + if (redial_count >= 1 AND redial_count <= 3) + { + timStart(redialTim24); + call_stat = REDIALING_CALL; + cc_stat.call_number = 0; + return; + } + + if (redial_count >= 4 AND redial_count < MAX_REDIAL_ATTEMPT) + { + timStart(redialTim5); + call_stat = REDIALING_CALL; + cc_stat.call_number = 0; + return; + } +#ifdef CUSTOMER_6366 + // JP PATCH The MMI needs to know if the 'error disconnect' has + // resulted in redial starting irrespective of whether this was a redial attempt or not + rdl.redial_mode = CM_REDIAL_STARTED; + cm_signal(E_CM_REDIAL, &rdl); + // END JP PATCH +#endif /* CUSTOMER_6366 */ + break; + + default: + if (redial_count) + { + rdl.redial_mode = CM_REDIAL_STOP; + mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN); +#ifdef NO_ASCIIZ + rdl.name.len = cc_stat.name.len; + memcpy(rdl.name.data, + cc_stat.name.data, + cc_stat.name.len); +#else + mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN);//??? +// strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr); +#endif + rdl.ton = cc_stat.ton; + rdl.type = cc_stat.mode; + cm_signal(E_CM_REDIAL, &rdl); + } + /* allow a new outgoing */ + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cc_stat.type = MFW_CALL_FREE; + return; + } +#ifdef FF_MMI_OPTIM + if (redial_count >= MAX_REDIAL_ATTEMPT + AND count < MAX_BLACKLIST_NUM) + { + mfwStrncpy((char *)blackListNum,(char *)cc_stat.number, MFW_NUM_LEN); +// Apr 14, 2005 REF: CRR 29991 xpradipg +// once there is new addition update it onto the file + if(flash_MMI_blackList_write((U8*)blackListNum, MFW_NUM_LEN, (count*MFW_NUM_LEN)+1) < 0) + TRACE_FUNCTION("ERROR OPENING the blacklist file"); + count++; + if(flash_MMI_blackList_write((U8*)&count,1,0) < 0) + TRACE_FUNCTION("ERROR OPENING the blacklist file"); +#else + if (redial_count >= MAX_REDIAL_ATTEMPT + AND black_list.count < MAX_BLACKLIST_NUM) + { + mfwStrncpy((char *)black_list.number[black_list.count], + (char *)cc_stat.number, MFW_NUM_LEN); + black_list.count++; +#endif + rdl.redial_mode = CM_REDIAL_BLACKLISTED; + mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN); +#ifdef NO_ASCIIZ + rdl.name.len = cc_stat.name.len; + memcpy(rdl.name.data, + cc_stat.name.data, + cc_stat.name.len); +#else + mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN); +// strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr); +#endif + rdl.ton = cc_stat.ton; + rdl.type = cc_stat.mode; + rdl.left_attempts = 0; + cc_stat.call_number = 0; + cm_signal(E_CM_REDIAL, &rdl); + } + } + + /* allow a new outgoing */ + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cc_stat.type = MFW_CALL_FREE; +} +#endif + + +/* ++-----------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_rmt_error_connect | ++-----------------------------------------------------------------------+ + + + PURPOSE : The connection is not successful + +*/ + +#ifdef FF_2TO1_PS +void cm_rmt_error_connect(SHORT call_number) +{ + T_CAUSE_ps_cause report; /* Marcus: Extended error reporting: 12/11/2002 */ + + TRACE_FUNCTION ("cm_error_connect()"); + +//TISH: OMAPS00104986 if there is inband tone, it should not disconnect the call, until User reject it. + if (cm_cpi.inband) return; + /* send event */ + dis_connect.call_number = call_number; + + qAT_PlusCEER( CMD_SRC_LCL, &report); + /* Marcus: Extended error reporting: 12/11/2002: Start */ +// TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report); + + if (report.ctrl_value != CAUSE_is_from_nwcc) + { + /* Treat Condat defined cause values as if no cause given */ + dis_connect.cause = NOT_PRESENT_8BIT; + } + else + { + /* Standards defined cause value is given */ + dis_connect.cause = report.value.nwcc_cause; + } + + TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause); + /* Marcus: Extended error reporting: 12/11/2002: End */ + + cm_signal(E_CM_DISCONNECT, &dis_connect); +} +#else +void cm_rmt_error_connect(SHORT call_number) +{ + USHORT report; /* Marcus: Extended error reporting: 12/11/2002 */ + + TRACE_FUNCTION ("cm_error_connect()"); + //TISH: OMAPS00104986 if there is inband tone, it should not disconnect the call, until User reject it. + if (cm_cpi.inband) return; + + /* send event */ + dis_connect.call_number = call_number; + + qAT_PlusCEER( CMD_SRC_LCL, &report); + /* Marcus: Extended error reporting: 12/11/2002: Start */ + TRACE_EVENT_P1("qAT_PlusCEER(%04X)", report); + if (GET_CAUSE_DEFBY(report) == DEFBY_CONDAT) + { + /* Treat Condat defined cause values as if no cause given */ + dis_connect.cause = NOT_PRESENT_8BIT; + } + else + { + /* Standards defined cause value is given */ + dis_connect.cause = GET_CAUSE_VALUE(report); + } + TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause); + /* Marcus: Extended error reporting: 12/11/2002: End */ + + cm_signal(E_CM_DISCONNECT, &dis_connect); +} +#endif + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_disconnect | ++--------------------------------------------------------------------+ + + + PURPOSE : Disconnection for outgoing call or active call + +*/ + +T_MFW cm_disconnect(SHORT call_number) +{ + CHAR callId[5]; + T_MFW_CM_CALL_STAT stat; + UBYTE ton; + UBYTE mode; + + TRACE_FUNCTION ("cm_disconnect()"); + + dis_connect.call_number = call_number; + + /*Apr 25, 2006 OMAPS00075711 a0393213 (R.Prabakar) + Description : 'End Conference' option doesn't work + Solution : The ACI_CHLD_MOD is changed from CHLD_MOD_RelActSpec to CHLD_MOD_RelActAndAcpt while calling sAT_PlusCHLD(). + This is done since CHLD_MOD_RelActSpec with callId 0 is equivalent to sending AT+CHLD=10 which is invalid + according to GSM specification. Before calling sAT_PlusCHLD command status is also set*/ + + if (!call_number) + { + sprintf(callId, "%d", 0); + cm_set_cmd_status(CHLD_MOD_RelActAndAcpt, callId); + if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActAndAcpt, callId) != AT_EXCT) + return CM_ERROR; + return CM_OK; + } + + cm_search_callStat(call_number, &stat, &ton, &mode); + + TRACE_EVENT_P3("Status %d Ton %d Mode %d",stat,ton,mode); + + /* HANG UP DATA CALL (WAP) + * SPR#1983 - SH - Use sAT_Abort() when call has not yet connected, + * rather than sAT_H */ + + if (mode == DATA_CALL) + { + T_ACI_RETURN retval; + + TRACE_EVENT_P1("***Disconnect data call, stat=%d", stat); + + if ((stat == CALL_DIAL) OR (stat == CALL_ALERT)) + { + if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) NEQ AT_CMPL) + return CM_ERROR; + return CM_OK; + } + + if (stat == CALL_DEACTIVE && currConnecting) /* ES/AK 290999 */ + { + currConnecting = 0; + if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) NEQ AT_CMPL) + return CM_ERROR; + return CM_OK; + } + + retval = sAT_H(CMD_SRC_LCL); + + TRACE_EVENT_P1("Result of sAT_H = %d", retval); + if (retval) + return CM_ERROR; + return CM_OK; + } + + + if ((stat == CALL_DIAL) OR (stat == CALL_ALERT)) + { + if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) NEQ AT_CMPL) + return CM_ERROR; + return CM_OK; + } + + if (stat == CALL_DEACTIVE && currConnecting) /* ES/AK 290999 */ + { + currConnecting = 0; + if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) NEQ AT_CMPL) + return CM_ERROR; + return CM_OK; + } + + if ((stat == CALL_ACTIVE) OR (stat == CALL_DEACTIVE)) + { + cmd_hold = MFW_CM_TERMINATED; + sprintf(callId, "%d", call_number); + if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActSpec, callId) != AT_EXCT) + return CM_ERROR; + return CM_OK; + } + else if (stat == CALL_HELD) + { + + + // Apr 26, 2004 REF: CRR 16545 Ajith K P Side effect of CRR 16545. + // CHLD_MOD_RelActSpec no longer releases held calls. + // So now if the user wants to release a HELD call, now we are calling the + // sAT_PlusCHLD(..) function with CHLD_MOD_RelAnySpec as the parameter. + + + + cmd_hold = MFW_CM_TERMINATED; + sprintf(callId, "%d", call_number); + // Feb 27, 2006 REF:DR OMAPS00067884 x0039928 + // Fix : sAT_PercentCHLD() is called if the mode > CHLD_MOD_RelDialCall + if (sAT_PercentCHLD(CMD_SRC_LCL, CHLD_MOD_RelAnySpec, callId) != AT_EXCT) + return CM_ERROR; + return CM_OK; + } + return CM_ERROR; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_force_disconnect | ++--------------------------------------------------------------------+ + + + PURPOSE : Disconnection of any call existent needed for Multiparty and some structured procedures + call termination in state U9 + +*/ + +void cm_force_disconnect(void) +{ + T_ACI_RETURN res; + + TRACE_FUNCTION("cm_force_disconnect()"); + + res = sAT_H(CMD_SRC_LCL); + if (res != AT_EXCT && res != AT_CMPL) + TRACE_ERROR("satReject() error"); + + return; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_ok_disconnect | ++--------------------------------------------------------------------+ + + + PURPOSE : indicates disconnection from called party; + sends E_CM_DISCONNECT to mmi + +*/ + +#ifdef FF_2TO1_PS +void cm_ok_disconnect(T_ACI_CMD_SRC src, SHORT call_id) +{ + T_CAUSE_ps_cause cause; /* Marcus: Extended error reporting: 12/11/2002 */ + T_MFW_CM_DISCONNECT_ALL disconnect_all; + + TRACE_FUNCTION("cm_ok_disconnect()"); + + TRACE_EVENT_P4("dis_connect.call_number %d, cmd_hold %d, src %d, call_id %d", + dis_connect.call_number, cmd_hold, src, call_id); + + + + + /* Marcus: CCBS: 14/11/2002: Start */ + if (cmd_hold == MFW_CM_CCBS_REGISTER) + { + /* Rejecting the offered CCBS registration */ + TRACE_EVENT("cmd_hold == MFW_CM_CCBS_REGISTER"); + cmd_hold = 0; + cm_ccbs_ok(); + return; + } + /* Marcus: CCBS: 14/11/2002: End */ + + if (cmd_hold == MFW_CM_MPTY_TERMINATED) + dis_connect.call_number = 0; + //Nov 02, 2005 DR OMAPS00052132 xdeepadh + //The usage of ATI enum is put under the flag FF_ATI +#if defined (FF_ATI) || defined (NEPTUNE_BOARD) + else if (src EQ CMD_SRC_ATI_1) /* NM Berlin/UK integration 21.09.01 */ + { + dis_connect.call_number = call_id; + } +#endif + + + /* send event */ + qAT_PlusCEER( CMD_SRC_LCL, &cause); + /* Marcus: Extended error reporting: 12/11/2002: Start */ +// TRACE_EVENT_P1("qAT_PlusCEER(%04X)", cause); + + if (cause.ctrl_value != CAUSE_is_from_nwcc) + { + /* Treat Condat defined cause values as if no cause given */ + dis_connect.cause = NOT_PRESENT_8BIT; + } + else + { + /* Standards defined cause value is given */ + dis_connect.cause = cause.value.nwcc_cause; + } + + TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause); + /* Marcus: Extended error reporting: 12/11/2002: End */ + + /* allow a new outgoing */ + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + + if (cmd_hold EQ MFW_CM_DISCONNECT_ALL) + { + disconnect_all.result = CM_DISCONNECT_ALL_RESULT_OK; + if (cause.ctrl_value != CAUSE_is_from_nwcc) + { + /* Treat Condat defined cause values as if no cause given */ + disconnect_all.cause = NOT_PRESENT_8BIT; + } + else + { + /* Standards defined cause value is given */ + disconnect_all.cause = cause.value.nwcc_cause; + } + cm_signal(E_CM_DISCONNECT_ALL,&disconnect_all); + } + else + cm_signal(E_CM_DISCONNECT, &dis_connect); + + cmd_hold = 0; + +} +#else +void cm_ok_disconnect(T_ACI_CMD_SRC src, SHORT call_id) +{ + USHORT cause; /* Marcus: Extended error reporting: 12/11/2002 */ + T_MFW_CM_DISCONNECT_ALL disconnect_all; + + TRACE_FUNCTION("cm_ok_disconnect()"); + + TRACE_EVENT_P4("dis_connect.call_number %d, cmd_hold %d, src %d, call_id %d", + dis_connect.call_number, cmd_hold, src, call_id); + + + + + /* Marcus: CCBS: 14/11/2002: Start */ + if (cmd_hold == MFW_CM_CCBS_REGISTER) + { + /* Rejecting the offered CCBS registration */ + TRACE_EVENT("cmd_hold == MFW_CM_CCBS_REGISTER"); + cmd_hold = 0; + cm_ccbs_ok(); + return; + } + /* Marcus: CCBS: 14/11/2002: End */ + + if (cmd_hold == MFW_CM_MPTY_TERMINATED) + dis_connect.call_number = 0; + //Nov 02, 2005 DR OMAPS00052132 xdeepadh + //The usage of ATI enum is put under the flag FF_ATI +#ifdef FF_ATI + else if (src EQ CMD_SRC_ATI_1) //NM Berlin/UK integration 21.09.01 + { + dis_connect.call_number = call_id; + } +#endif //FF_ATI + + /* send event */ + qAT_PlusCEER( CMD_SRC_LCL, &cause); + /* Marcus: Extended error reporting: 12/11/2002: Start */ + TRACE_EVENT_P1("qAT_PlusCEER(%04X)", cause); + if (GET_CAUSE_DEFBY(cause) == DEFBY_CONDAT) + { + /* Treat Condat defined cause values as if no cause given */ + dis_connect.cause = NOT_PRESENT_8BIT; + } + else + { + /* Standards defined cause value is given */ + dis_connect.cause = GET_CAUSE_VALUE(cause); + } + TRACE_EVENT_P1("dis_connect.cause = %02X)", dis_connect.cause); + /* Marcus: Extended error reporting: 12/11/2002: End */ + + /* allow a new outgoing */ + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + + if (cmd_hold EQ MFW_CM_DISCONNECT_ALL) + { + disconnect_all.result = CM_DISCONNECT_ALL_RESULT_OK; + if (GET_CAUSE_DEFBY(cause) == DEFBY_CONDAT) + { + /* Treat Condat defined cause values as if no cause given */ + disconnect_all.cause = NOT_PRESENT_8BIT; + } + else + { + /* Standards defined cause value is given */ + disconnect_all.cause = GET_CAUSE_VALUE(cause); + } + cm_signal(E_CM_DISCONNECT_ALL,&disconnect_all); + } + else + cm_signal(E_CM_DISCONNECT, &dis_connect); + + cmd_hold = 0; + +} +#endif + +/* Marcus: CCBS: 14/11/2002: Start */ +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_error_disconnect | ++--------------------------------------------------------------------+ + + PURPOSE : indicates failed disconnection + +*/ +void cm_error_disconnect(void) +{ + TRACE_FUNCTION ("cm_error_disconnect()"); + if (cmd_hold == MFW_CM_DISCONNECT_ALL) + { + TRACE_EVENT("cmd_hold == MFW_CM_DISCONNECT_ALL"); + cmd_hold = 0; + } + + /* Marcus: CCBS: 14/11/2002: Start */ + if (cmd_hold == MFW_CM_CCBS_REGISTER) + { + TRACE_EVENT("cmd_hold == MFW_CM_CCBS_REGISTER"); + /* Rejecting the offered CCBS registration */ + cmd_hold = 0; + cm_ccbs_error(); + } +} +/* Marcus: CCBS: 14/11/2002: End */ + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_command | ++--------------------------------------------------------------------+ + + + PURPOSE : + +*/ + +T_MFW cm_command(SHORT call_number, UBYTE command, UBYTE crss_string) +{ + CHAR callId[5]; + UBYTE res; + SHORT retVal, modeRetVal; // xnkulkar SPR-18262: Added "modeRetVal" to store the return value of "mfw_cbuf_put_mode ()" + + TRACE_FUNCTION ("cm_command()"); + +// JP PATCH + cmd_hold = 0; +// END PATCH + + cmd.call_number = call_number; + cmd.command = command; + + switch (command) + { + case CM_HOLD: + case CM_SWAP: + case CM_RETRIEVE: + case CM_SWAP_MULTIPARTY: + case CM_HOLD_MULTIPARTY: + case CM_RETRIEVE_MULTIPARTY: + /* place all active calls on held and accept held or waiting call */ + if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_HldActAndAcpt, 0) != AT_EXCT) + return FALSE; + break; + + case CM_BUILD_MULTIPARTY: + if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_AddHld, 0)!= AT_EXCT) + return FALSE; + break; + + case CM_SPLIT_MULTIPARTY: + if (call_number <= 0) + return FALSE; + sprintf(callId, "%d", call_number); + if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_HldActExc, callId)!= AT_EXCT) + return FALSE; + break; + + case CM_ETC: + /* connects two calls and disconnects the subsrciber from both calls */ + if (sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_Ect, 0) != AT_EXCT) + return FALSE; + break; + + case CM_CALL_DEFLECTION: + break; + + case CM_CCBS: + TRACE_EVENT("CM_CCBS"); + sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_Ccbs, 0); + break; + + case CM_MODIFY: + break; + + case CM_DTMF_ACTIVE: + // xnkulkar SPR-18262 + // If there is a DTMF tone command already in the queue, add the current tone also + // in the queue (with start mode). Also, start adding to the queue if we are expecting an acknowledgement + // (rAT_OK) for the previous DTMF tone request sent. + /*OMAPS00108192 a0393213 DTMF START-DTMF STOP properly nested*/ + if (mfw_cbuf_num_elements(mfw_cm_dtmf_q_id) != 0) + { + /*dtmf queue not empty*/ + if(dtmf_queued.mode==VTS_MOD_ManStop) + { + /*most recent element in the queue corresponds to 'stop'*/ + /*queue up*/ + modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_ManStart); + retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string); + // If the return values are negative, attempt to Queue the DTMF request failed + if (retVal < 0 || modeRetVal < 0) + { + TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal); + TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal); + /* + ** Failed to Queue the DTMF request. + */ + return(FALSE); + } + /*successfully queued update the internal variable*/ + dtmf_queued.mode=VTS_MOD_ManStart; + dtmf_queued.digit=crss_string; + return (TRUE); + } + else + { + /*ignore the key press*/ + return (TRUE); + } + + } + else + { + /*dtmf queue empty*/ + if(dtmf_sent.valid==TRUE) + { + /*some dtmf has already been sent to ACI and MMI is waiting for rAT_ok*/ + if(dtmf_sent.mode==VTS_MOD_ManStop) + { + /*last sent dtmf is STOP - so queue up*/ + modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_ManStart); + retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string); + // If the return values are negative, attempt to Queue the DTMF request failed + if (retVal < 0 || modeRetVal < 0) + { + TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal); + TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal); + /* + ** Failed to Queue the DTMF request. + */ + return(FALSE); + } + /*successfully queued update the internal variable*/ + dtmf_queued.mode=VTS_MOD_ManStart; + dtmf_queued.digit=crss_string; + return (TRUE); + } + else + { + return (TRUE); /*ignore the key press*/ + } + } + else + { + /*we are not waiting for any rAT_ok - so call sAT_PlusVTS*/ + if(sAT_PlusVTS(CMD_SRC_LCL, (CHAR)crss_string, VTS_MOD_ManStart) == AT_EXCT) + { + TRACE_EVENT("sAT_PlusVTS() successful"); + dtmf_sent.valid=TRUE; + dtmf_sent.mode=VTS_MOD_ManStart; + dtmf_sent.digit=crss_string; + } + else + { + TRACE_EVENT("sAT_PlusVTS() busy or failed"); + return (FALSE); + } + } + + } + #ifdef MMI_LINT_WARNING_REMOVAL /*a0393213 lint warnings removal*/ + currCmd = AT_CMD_VTS; + #endif + break; + + case CM_DTMF_INACTIVE: + // xnkulkar SPR-18262 + // If there is a DTMF tone command already in the queue, add the current tone also + // in the queue (with stop mode). Also, start adding to the queue if we are expecting an acknowledgement + // (rAT_OK) for the previous DTMF tone request sent. + /*OMAPS00108192 a0393213 DTMF START-DTMF STOP properly nested*/ + if (mfw_cbuf_num_elements(mfw_cm_dtmf_q_id) != 0) + { + /*dtmf queue not empty*/ + if(dtmf_queued.mode==VTS_MOD_ManStart && dtmf_queued.digit==crss_string) + { + /*most recent element in the queue corresponds to START and are of same digit so queue up*/ + modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_ManStop); + retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string); + // If the return values are negative, attempt to Queue the DTMF request failed + if (retVal < 0 || modeRetVal < 0) + { + TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal); + TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal); + /* + ** Failed to Queue the DTMF request. + */ + return(FALSE); + } + /*successfully queued update the internal variable*/ + dtmf_queued.mode=VTS_MOD_ManStop; + dtmf_queued.digit=crss_string; + return (TRUE); + } + else + { + /*ignore the key press*/ + return (TRUE); + } + + } + else + { + /*dtmf queue empty*/ + if(dtmf_sent.valid==TRUE) + { + /*some dtmf has already been sent to ACI and MMI is waiting for rAT_ok*/ + if(dtmf_sent.mode==VTS_MOD_ManStart && dtmf_sent.digit==crss_string) + { + /*last sent dtmf corresponds to START and are of same digit - so queue up*/ + modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_ManStop); + retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string); + // If the return values are negative, attempt to Queue the DTMF request failed + if (retVal < 0 || modeRetVal < 0) + { + TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal); + TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal); + /* + ** Failed to Queue the DTMF request. + */ + return(FALSE); + } + /*successfully queued update the internal variable*/ + dtmf_queued.mode=VTS_MOD_ManStop; + dtmf_queued.digit=crss_string; + return (TRUE); + } + else + { + return (TRUE); /*ignore the key press*/ + } + } + else + { + /*rAT_ok is not expected. so call sAT_PlusVTS*/ + if(sAT_PlusVTS(CMD_SRC_LCL, (CHAR)crss_string, VTS_MOD_ManStop) == AT_EXCT) + { + TRACE_EVENT("sAT_PlusVTS() successful"); + dtmf_sent.valid=TRUE; + dtmf_sent.mode=VTS_MOD_ManStop; + dtmf_sent.digit=crss_string; + } + else + { + TRACE_EVENT("sAT_PlusVTS() busy or failed"); + return (FALSE); + } + } + + } + res = TRUE; + cm_signal(E_CM_DTMF, &res); + break; + + case CM_DTMF_AUTO: + /*OMAPS00108192 a0393213(R.Prabakar) + As part of the issue CM_DTMF_ACTIVE and CM_DTMF_INACTIVE cases modified. But this case is not modified + because this case is felt irrelavant. If required the same logic can be extended to this case also*/ + if (mfw_cbuf_num_elements(mfw_cm_dtmf_q_id) != 0) + { + /* + ** There are already DTMF tones queued to be sent, so queue this request to. + */ + modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_Auto); + retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string); + if (retVal < 0 || modeRetVal < 0) + { + TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal); + TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal); + /* + ** Failed to Queue the DTMF request. + */ + return(FALSE); + } + } + else + { + if (sAT_PlusVTS(CMD_SRC_LCL, (CHAR)crss_string, VTS_MOD_Auto) != AT_EXCT) + { + /* + ** The attempt to send an immediate DTMF failed. + ** Add the failed attempt onto the DTMF queue and wait. + */ + modeRetVal = mfw_cbuf_put_mode(mfw_cm_dtmf_q_id, VTS_MOD_Auto); + retVal = mfw_cbuf_put(mfw_cm_dtmf_q_id, &crss_string); + if (retVal < 0 || modeRetVal < 0) + { + TRACE_EVENT_P1("ERROR : mfw_cbuf_put failed with error %d", retVal); + TRACE_EVENT_P1("ERROR : mfw_cbuf_put_mode failed with error %d", modeRetVal); + /* + ** Failed to Queue the DTMF request. + */ + return(FALSE); + } + } + } + break; + + default: + break; + } + return TRUE; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : send_queued_dtmf_tone | ++--------------------------------------------------------------------+ + + + PURPOSE : Check the DTMF Queue and if required send the next DTMF Tone Request. + +*/ +static void send_queued_dtmf_tone(void) +{ + SHORT retVal; + UBYTE qdtmf; + //xnkulkar SPR-18262: Added these variables to store the Mode + T_ACI_VTS_MOD vts_mode = VTS_MOD_NotPresent; + + TRACE_EVENT("send_queued_dtmf_tone()"); + /*OMAPS00108192 a0393213*/ + if (mfw_cbuf_num_elements(mfw_cm_dtmf_q_id) > 0) + { + /*dtmf queue has some elements - so dequeue and send to ACI*/ + // Get the mode (Start / Stop) corresponding to the DTMF tone + vts_mode = (T_ACI_VTS_MOD)mfw_cbuf_get_mode(mfw_cm_dtmf_q_id); + // Get the DTMF key for which the tone is to be sent from the queue + retVal = mfw_cbuf_get(mfw_cm_dtmf_q_id, &qdtmf); + if (retVal > 0) + { + if (sAT_PlusVTS(CMD_SRC_LCL, (CHAR)qdtmf, vts_mode) == AT_EXCT) + { + dtmf_sent.valid=TRUE; + dtmf_sent.mode=vts_mode; + dtmf_sent.digit=qdtmf; + } + + } + else + { + TRACE_EVENT_P1("ERROR : mfw_cbuf_get failed with error value %d", retVal); + dtmf_sent.valid=FALSE; + } + + } + else + { + dtmf_sent.valid=FALSE; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : resetDTMFQueue | ++--------------------------------------------------------------------+ + PURPOSE : reset the dtmf queue +*/ +/*OMAPS00107103 (no dtmf tones for simultaneous key press) a0393213(R.Prabakar) - function added*/ +void resetDTMFQueue() +{ + TRACE_EVENT("resetDTMFQueue"); + mfw_cbuf_reset(mfw_cm_dtmf_q_id); + //expectRatOk=FALSE; + dtmf_sent.valid=FALSE; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_ok_dtmf | ++--------------------------------------------------------------------+ + + + PURPOSE : DTMF activation is successful. + +*/ + +void cm_ok_dtmf(void) +{ + UBYTE res; + #ifdef MMI_LINT_WARNING_REMOVAL /*a0393213 lint warnings removal*/ + currCmd = AT_CMD_NONE; + #endif + res = TRUE; + cm_signal(E_CM_DTMF, &res); + + send_queued_dtmf_tone(); + + return; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_error_tdmf | ++--------------------------------------------------------------------+ + + + PURPOSE : DTMF activation is failed. + +*/ + +void cm_error_dtmf(void) +{ + UBYTE res; +#ifdef MMI_LINT_WARNING_REMOVAL /*a0393213 lint warnings removal*/ + currCmd = AT_CMD_NONE; +#endif + res = FALSE; + cm_signal(E_CM_DTMF, &res); + + send_queued_dtmf_tone(); + +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_result_cmd | ++--------------------------------------------------------------------+ + + + PURPOSE : Acknowledgement for the requested ss command. + +*/ + +void cm_result_cmd(T_ACI_CMD_SRC src, UBYTE result) +{ + SHORT call_number; + + TRACE_EVENT_P1("cm_result_cmd(), cmd_hold = %d", cmd_hold); + + /* MC changed all the "if"s to a switch to allow default 11/04/02*/ + switch (cmd_hold) + { + case MFW_CM_MT_REJECT: + break; /* CONQUEST 6040- MC- put a break in the case so no action taken*/ + case MFW_CM_MPTY_TERMINATED: + case MFW_CM_TERMINATED: + + { + if (result EQ Present) + cm_ok_disconnect(CMD_SRC_LCL, 0); + return; + } +// break; // RAVI + + case MFW_CM_MT_ACCEPT: + { + /* + * active call on hold, accept new incoming call + */ + cmd_hold = 0; + if (result EQ Present) + /* + * Call on hold was successful + */ + cm_ok_connect(); + + else + { + if (cm_search_callId(CAL_STAT_Active, &call_number) != CM_OK) + return; + cmd.call_number = call_number; +#ifdef MMI_LINT_WARNING_REMOVAL /*a0393213 lint warnings removal*/ + cc_id = 0; // ??? +#endif + } + } + break; + + + case MFW_CM_HOLD_AND_DIAL: + { + /* + * active call on hold, accept new incoming call + */ + cmd_hold = 0; + if (result EQ Present) + /* + * Call on hold was successful + */ + cm_ok_connect(); + + else + { + if (cm_search_callId(CAL_STAT_Active, &call_number) != CM_OK) + return; + cmd.call_number = call_number; +#ifdef MMI_LINT_WARNING_REMOVAL /*a0393213 lint warnings removal*/ + cc_id = 0; // ??? +#endif + } + } + break; + + case MFW_CM_1_SEND: + { + + cmd_hold = 0; + if (result == Present) + { + // MMI-SPR 13873 xkundadu + // Handling of 1SEND + // If the user presses 1SEND, release active calls and accept + // the WAITING call + if (dis_connect.call_number NEQ -1) + { + // If there is an active call, disconnect it. + cm_ok_disconnect(CMD_SRC_LCL, 0); + } + + if (!cmd.call_number) + { + // If there is waiting call, accept the call + cm_ok_connect(); + } + cmd.call_number = -1; + } + + } + break; + + /* Marcus: CCBS: 14/11/2002: Start */ + case MFW_CM_CCBS_REGISTER: + + TRACE_EVENT("MFW_CM_CCBS_REGISTER"); + + cmd_hold = 0; + + if (result == Present) + { + TRACE_EVENT("result == Present"); + cm_ccbs_ok(); + } + else /* result is NotPresent */ + { + TRACE_EVENT("result != Present"); + cm_ccbs_error(); + } + return; + + case MFW_CM_CCBS_RECALL: + + TRACE_EVENT("MFW_CM_CCBS_RECALL"); + + cmd_hold = 0; + + if (result == Present) + { + TRACE_EVENT("result == Present"); + cm_ccbs_ok(); + } + else /* result is NotPresent */ + { + TRACE_EVENT("result != Present"); + cm_ccbs_error(); + } + return; + /* Marcus: CCBS: 14/11/2002: Start */ + + default:/*For other command types ensure correct result is passed up to BMI*/ + { + cmd.result = result; + } + break; + } + + +#if defined (WIN32) + { + char buf[40]; + sprintf (buf, "Event CM_COMMAND for %d", cmd.call_number); + TRACE_EVENT (buf); + sprintf (buf, "Result %d Command %d",cmd.result, cmd.command); + TRACE_EVENT (buf); + } +#endif + cmd.result = result; + cm_signal(E_CM_COMMAND, &cmd); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_cvt_speed_type | ++--------------------------------------------------------------------+ + + + PURPOSE : This function is used to convert the type of data rate + used by MFW to the type of data rate used by ACI. + +*/ + +LOCAL T_ACI_BS_SPEED cm_cvt_speed_type ( T_MFW_CM_DATA_SPEED speed ) +{ + switch ( speed ) + { + case ( SPEED_300 ): return BS_SPEED_300_V110; + case ( SPEED_1200 ): return BS_SPEED_1200_V110; + case ( SPEED_2400 ): return BS_SPEED_2400_V110; + case ( SPEED_4800 ): return BS_SPEED_4800_V110; + case ( SPEED_9600 ): return BS_SPEED_9600_V110; + case ( SPEED_14400 ): return BS_SPEED_14400_V110; + default: return BS_SPEED_NotPresent; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_cvt_bs_type | ++--------------------------------------------------------------------+ + + + PURPOSE : This function is used to convert the type of bearer service + used by MFW to the type of bearer service used by ACI. + +*/ + +LOCAL T_ACI_CBST_NAM cm_cvt_bs_type ( T_MFW_CM_BS bs ) +{ + switch ( bs ) + { + case ( Asynch ): return CBST_NAM_Asynch; + case ( Synch ): return CBST_NAM_Synch; + default: return CBST_NAM_NotPresent; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_cvt_ce_type | ++--------------------------------------------------------------------+ + + + PURPOSE : This function is used to convert the data mode + used by MFW to the data mode used by ACI. + +*/ + +LOCAL T_ACI_CBST_CE cm_cvt_ce_type ( T_MFW_CM_CE ce ) +{ + switch ( ce ) + { + case ( Transparent ): return CBST_CE_Transparent; + case ( NonTransparent ): return CBST_CE_NonTransparent; + default: return CBST_CE_NotPresent; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_set_bc_para | ++--------------------------------------------------------------------+ + + + PURPOSE : Set bearer parameter for mobile originated calls. + +*/ + +void cm_set_bc_para(T_MFW_CM_BC_PARA * bc, UBYTE ti) +{ + TRACE_FUNCTION ("cm_set_bc_para()"); +#ifdef FAX_AND_DATA + sAT_PlusCBST(CMD_SRC_LCL, + cm_cvt_speed_type ((T_MFW_CM_DATA_SPEED)bc->rate), + cm_cvt_bs_type ((T_MFW_CM_BS)bc->bearer_serv), + cm_cvt_ce_type ((T_MFW_CM_CE)bc->conn_elem)); +#endif /* FAX_AND_DATA */ +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_notify | ++--------------------------------------------------------------------+ + + + PURPOSE : Change of SS status from call party. + +*/ +void cm_notify(T_ACI_CSSU_CODE code, + SHORT index, + UBYTE *number) +{ char debug[50]; + sprintf(debug,"cm_notify(), code:%d, index:%d" , code, index); + TRACE_EVENT(debug); + if (number) + notify.call_number = index; + + if (code == CSSU_CODE_OnHold) + notify.notification = MFW_CM_HOLD; + if (code == CSSU_CODE_Retrieved) + notify.notification = MFW_CM_RETRIEVED; + + cm_signal(E_CM_NOTIFY, ¬ify); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_get_aoc_value | ++--------------------------------------------------------------------+ + + + PURPOSE : Getting AoC (advice of charge) value. + +*/ + +T_MFW cm_get_aoc_value(UBYTE request_type, T_MFW_CM_AOC_INFO *aoc_info) +{ + T_ACI_RPCT_VAL rpuct; + + TRACE_FUNCTION ("cm_get_aoc_value()"); + + switch (request_type) + { + /* Price pro unit and currency table */ + case CM_AOC_PUCT: + if (qAT_PlusCPUC(CMD_SRC_LCL, + (CHAR *)aoc_info->cur, + (CHAR *)aoc_info->ppu) == AT_CMPL) + { + aoc_info->requested_type = CM_AOC_PUCT; + return CM_OK; + } + else + return CM_NO_AOC; +// break; // RAVI + + /* maximum value of accumulated Call Meter */ + case CM_AOC_ACMMAX: + if (qAT_PlusCAMM(CMD_SRC_LCL, &aoc_info->acm_max) == AT_CMPL) + { + aoc_info->requested_type = CM_AOC_ACMMAX; + return CM_OK; + } + else + return CM_NO_AOC; +// break; // RAVI + + /* Accumulated Call Meter */ + case CM_AOC_ACM: + if (qAT_PlusCACM(CMD_SRC_LCL, &aoc_info->acm) == AT_CMPL) + { + aoc_info->requested_type = CM_AOC_ACM; + return CM_OK; + } + else + return CM_NO_AOC; + // break; // RAVI + + case CM_AOC_CCM: + if (qAT_PlusCAOC(CMD_SRC_LCL, &aoc_info->ccm) == AT_CMPL) + { + aoc_info->requested_type = CM_AOC_CCM; + return CM_OK; + } + else + return CM_NO_AOC; +// break; // RAVI + + case CM_AOC_TIMERS: + if (qAT_PercentCTV(CMD_SRC_LCL, &aoc_info->actual_call_timer) == AT_CMPL) + { + aoc_info->requested_type = CM_AOC_TIMERS; + return CM_OK; + } + else + return CM_NO_AOC; +// break; // RAVI + + case CM_AOC_CCM_PUCT: + if (qAT_PercentCAOC(CMD_SRC_LCL, (CHAR *)aoc_info->cur, (CHAR *)aoc_info->ccm_puct) == AT_CMPL) + { + aoc_info->requested_type = CM_AOC_CCM_PUCT; + return CM_OK; + } + else + return CM_NO_AOC; +// break; // RAVI + + case CM_AOC_ACM_PUCT: + if (qAT_PercentCACM(CMD_SRC_LCL, (CHAR *)aoc_info->cur, (CHAR *)aoc_info->acm_puct) == AT_CMPL) + { + aoc_info->requested_type = CM_AOC_ACM_PUCT; + return CM_OK; + } + else + return CM_NO_AOC; + case CM_AOC_RAW_PUCT: + if (qAT_PercentRPCT(CMD_SRC_LCL, &rpuct) == AT_CMPL) + { + aoc_info->requested_type = CM_AOC_RAW_PUCT; + strncpy((char *)aoc_info->cur, (char *)rpuct.currency, MAX_CUR_LEN); + aoc_info->eppu = rpuct.eppu; + aoc_info->exp = rpuct.exp; + aoc_info->sexp = rpuct.sexp; + return CM_OK; + } + else + return CM_NO_AOC; +// break; // RAVI + + default: + return CM_NO_AOC; + } +} + + + +/* ++----------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_reset_aoc_value | ++----------------------------------------------------------------------+ + + + PURPOSE : Setting AoC (advice of charge) value. + +*/ + +T_MFW cm_set_aoc_value(UBYTE request_type, + T_MFW_CM_AOC_INFO *aoc_info, + UBYTE *pwd) +{ + TRACE_FUNCTION ("cm_reset_aoc_value()"); + + switch (request_type) + { + case CM_AOC_PUCT: + if (sAT_PlusCPUC(CMD_SRC_LCL, (CHAR *)aoc_info->cur, + (CHAR *)aoc_info->ppu, (CHAR *)pwd) != AT_EXCT) + return CM_ERROR; + break; + + case CM_AOC_ACMMAX: + if (sAT_PlusCAMM(CMD_SRC_LCL, aoc_info->acm_max, + (CHAR *)pwd) != AT_EXCT) + return CM_ERROR; + break; + + case CM_AOC_ACM: + if (sAT_PlusCACM(CMD_SRC_LCL, (CHAR *)pwd) != AT_EXCT) + return CM_ERROR; + break; + + default: + return CM_ERROR; + } + + return CM_OK; +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_cvt_cmd | ++----------------------------------------------------------------------+ + + + PURPOSE : Convert AoC command + +*/ + +UBYTE cm_cvt_cmd(T_ACI_AT_CMD cmdId) +{ + switch (cmdId) + { + case AT_CMD_CACM: return CM_AOC_ACM; + case AT_CMD_CAMM: return CM_AOC_ACMMAX; + case AT_CMD_CPUC: return CM_AOC_PUCT; + default: return CM_AOC_UNKNOWN; + } +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_ok_aoc | ++----------------------------------------------------------------------+ + + + PURPOSE : Setting AoC is successful. + +*/ + +void cm_ok_aoc(T_ACI_AT_CMD cmdId) +{ + T_MFW_CM_AOC_CNF aoc_cnf; + + aoc_cnf.requested_type = cm_cvt_cmd(cmdId); + aoc_cnf.result = CM_AOC_CONF_OK; + cm_signal(E_CM_AOC_CNF, &aoc_cnf); +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_error_aoc | ++----------------------------------------------------------------------+ + + + PURPOSE : Setting AoC is failure. + +*/ + +void cm_error_aoc(T_ACI_AT_CMD cmdId, T_ACI_CME_ERR reason) +{ + T_MFW_CM_AOC_CNF aoc_cnf; + + aoc_cnf.requested_type = cm_cvt_cmd(cmdId); + aoc_cnf.result = CM_AOC_CONF_UNKNOWN; + + if (reason EQ CME_ERR_SimPin2Req) + aoc_cnf.result = CM_AOC_CONF_SIMPIN2REQ; + + if (reason EQ CME_ERR_WrongPasswd) + aoc_cnf.result = CM_AOC_CONF_WRONGPASSWD; + + if (reason EQ CME_ERR_OpNotAllow) + aoc_cnf.result = CM_AOC_CONF_OPNOTALLOW; + + if (reason EQ CME_ERR_AcmResetNeeded) + aoc_cnf.result = CM_AOC_CONF_ACMRESETNEEDED; + + cm_signal(E_CM_AOC_CNF, &aoc_cnf); +} + + +/* ++-----------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : rAT_PercentCTV | ++-----------------------------------------------------------------+ + + + PURPOSE : manage timer in every second + +*/ + +void rAT_PercentCTV() +{ + TRACE_FUNCTION("rAT_PercentCTV()"); + cm_signal(E_CM_TIMER_EVERY_SECOND, 0); +} + + +/* ++-----------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : rAT_PlusCCCM | ++-----------------------------------------------------------------+ + + + PURPOSE : + +*/ + +void rAT_PlusCCCM(LONG *ccm) +{ + T_MFW_CM_AOC_INFO aoc_info; + T_ACI_RPCT_VAL rpuct; + + TRACE_FUNCTION("rAT_PlusCCCM()"); + + memset(&aoc_info, 0, sizeof(T_MFW_CM_AOC_INFO)); + + qAT_PlusCAMM(CMD_SRC_LCL, &aoc_info.acm_max); + qAT_PlusCACM(CMD_SRC_LCL, &aoc_info.acm); + aoc_info.ccm = *ccm; + qAT_PercentCTV(CMD_SRC_LCL, &aoc_info.actual_call_timer); + qAT_PercentRPCT(CMD_SRC_LCL, &rpuct); + strncpy((char *)aoc_info.cur, (char *)rpuct.currency, MAX_CUR_LEN); + aoc_info.requested_type = CM_AOC_CCM; + aoc_info.eppu = rpuct.eppu; + aoc_info.exp = rpuct.exp; + aoc_info.sexp = rpuct.sexp; + + cm_signal(E_CM_AOC, &aoc_info); +} + + +/* ++----------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_set_redial | ++----------------------------------------------------------------+ + + + PURPOSE : Set redial mode (automatic/manual). + +*/ + +void cm_set_redial(UBYTE redial_mode) +{ + // U8 version; // RAVI +// Apr 14, 2005 REF: CRR 29991 xpradipg +// local definition +#ifdef FF_MMI_OPTIM + T_MFW_CM_BLACKLIST_LIST black_list; +#endif + + TRACE_FUNCTION ("cm_set_redial()"); + + if (redial_mode == CM_REDIAL_BLACKLIST) + { + memset(&black_list, 0, sizeof(T_MFW_CM_BLACKLIST_LIST)); +// Apr 14, 2005 REF: CRR 29991 xpradipg +// reset the file contents +#ifdef FF_MMI_OPTIM + if(flash_MMI_blackList_write((U8 *)&black_list, sizeof(T_MFW_CM_BLACKLIST_LIST),0) < 0) + TRACE_FUNCTION(" Error writing into file"); +#endif + return; + } + + if (redial_mode == CM_REDIAL_OFF + || redial_mode == CM_REDIAL_AUTO + || redial_mode == CM_REDIAL_MANU) + { + redial_stat = redial_mode; + + /* write redialing mode to EEPROM */ + + FFS_flashData.redial_mode =redial_mode; + flash_write(); + + } +} + + +/* ++---------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_get_redial_mode | ++---------------------------------------------------------------------+ + + + PURPOSE : Request the setting of redial mode (automatic/manual). + +*/ + +T_MFW cm_get_redial_mode(void) +{ + return redial_stat; +} + + + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_stop_redialTim | ++--------------------------------------------------------------------+ + + + PURPOSE : Stop redialing time. + +*/ + +void cm_stop_redialTim(void) +{ + if (!redial_count) + timStop(redialTim1); + + if (redial_count >= 1 AND redial_count <= 3) + timStop(redialTim24); + + if (redial_count >= 4 AND redial_count < MAX_REDIAL_ATTEMPT) + timStop(redialTim5); + redial_count = 0; + rdl.left_attempts = 0; + + /* + reset the counter + */ + + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cc_stat.type = MFW_CALL_FREE; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_redial_abort | ++--------------------------------------------------------------------+ + + + PURPOSE : Stop redialing from MMI. + +*/ + +void cm_redial_abort(void) +{ + + TRACE_FUNCTION ("cm_redial_abort()"); + + if (call_stat == REDIALING_CALL OR call_stat == OUTGOING_CALL) + cm_stop_redialTim(); + + rdl.redial_mode = CM_REDIAL_ABORTED; + cm_signal(E_CM_REDIAL, &rdl); +} + + +/* ++---------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_autoredial_start | ++---------------------------------------------------------------------+ + + + PURPOSE : start autoredial. + +*/ + +void cm_autoredial_start(void) +{ + timStart(redialTim1); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_redial_timeout | ++--------------------------------------------------------------------+ + + + PURPOSE : Call back from system clock for redialing time interval. + +*/ + +static int cm_redial_timeout(MfwEvt e, MfwTim *t) +{ + CHAR number[MFW_NUM_LEN+MAX_LEN+1]; + int max_num_size = MFW_NUM_LEN+MAX_LEN+1; + + TRACE_FUNCTION ("cm_redial_timeout()"); + + memset(number, 0, sizeof(number)); + mfwStrncpy(number, (CHAR *)cc_stat.prefix, max_num_size); + max_num_size -= strlen((char *)cc_stat.prefix); + + if ((cc_stat.ton EQ MFW_TON_INTERNATIONAL) AND (cc_stat.number[0] != '+')) + { + strcat(number, "+"); + max_num_size--; + } + + strncat(number, (CHAR *)cc_stat.number, max_num_size); + + switch (redial_stat) + { + case CM_REDIAL_AUTO: + if (sAT_Dn(CMD_SRC_LCL, + (CHAR *)number, + D_CLIR_OVRD_Default, + D_CUG_CTRL_NotPresent, + D_TOC_Voice) NEQ AT_EXCT) + { + TRACE_ERROR("sAT_Dn error"); + return 0; + } + + call_stat = OUTGOING_CALL; + + cm_search_callId(CAL_STAT_Dial, &cc_stat.call_number); + cc_stat.type = REDIALING_CALL; + + rdl.redial_mode = CM_REDIAL_ATTEMPT; + rdl.call_id = cc_stat.call_number; + mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN); +#ifdef NO_ASCIIZ + rdl.name.len = cc_stat.name.len; + memcpy(rdl.name.data, + cc_stat.name.data, + cc_stat.name.len); +#else + mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN); +// strcpy((char *)rdl.subaddr, (char *)cc_stat.subaddr); +#endif + rdl.ton = cc_stat.ton; + rdl.type = cc_stat.mode; + redial_count++; + rdl.left_attempts = MAX_REDIAL_ATTEMPT - redial_count; + cm_signal(E_CM_REDIAL, &rdl); + return 1; + + case CM_REDIAL_MANU: + rdl.redial_mode = CM_REDIAL_MANU; + mfwStrncpy((char *)rdl.number, (char *)cc_stat.number, MFW_NUM_LEN); +#ifdef NO_ASCIIZ + rdl.name.len = cc_stat.name.len; + memcpy(rdl.name.data, + cc_stat.name.data, + cc_stat.name.len); +#else + mfwStrncpy((char *)rdl.name, (char *)cc_stat.name, MFW_TAG_LEN); +#endif + rdl.ton = cc_stat.ton; + rdl.type = cc_stat.mode; + rdl.left_attempts = MAX_REDIAL_ATTEMPT - redial_count; + + cm_signal(E_CM_REDIAL, &rdl); + return 1; + + default: + return 0; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_redial | ++--------------------------------------------------------------------+ + + + PURPOSE : Start the manual redialing. + +*/ + +void cm_redial() +{ + char buf[80]; + + int max_buf_size = sizeof(buf); + + TRACE_FUNCTION ("cm_redial()"); + + buf[0] = '\0'; + + mfwStrncpy(buf, (char *)cc_stat.prefix, max_buf_size); + max_buf_size -= strlen((char *)cc_stat.prefix); + + if ((cc_stat.ton EQ MFW_TON_INTERNATIONAL) AND (cc_stat.number[0] != '+')) + { + strcat(buf, "+"); + max_buf_size--; + } + + strncat(buf, (char *)cc_stat.number, max_buf_size); + + if (sAT_Dn(CMD_SRC_LCL, buf, D_CLIR_OVRD_Default, D_CUG_CTRL_NotPresent, D_TOC_Voice) NEQ AT_EXCT) /*a0393213 compiler warning removal -- -1 changed to respective enum value*/ + { + TRACE_ERROR("sAT_Dn error"); + } + + call_stat = OUTGOING_CALL; + cc_stat.type = REDIALING_CALL; + redial_count++; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_redial_get_count | ++--------------------------------------------------------------------+ + + + PURPOSE : returns the counter of call attempt + +*/ +UBYTE cm_redial_get_count(void) +{ + return redial_count; +} + + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_cvt_call_status | ++--------------------------------------------------------------------+ + + + PURPOSE : Convert the call status. + +*/ + +LOCAL T_MFW_CM_CALL_STAT cm_cvt_call_status( T_ACI_CAL_STAT stat ) +{ + switch ( stat ) + { + case ( CAL_STAT_Held ): return CALL_HELD; + case ( CAL_STAT_Active ): return CALL_ACTIVE; + case ( CAL_STAT_Wait ): return CALL_WAIT; + case ( CAL_STAT_Dial ): return CALL_DIAL; + case (CAL_STAT_Alerting): return CALL_ALERT; + case (CAL_STAT_DeactiveReq): return CALL_DEACTIVE; + default: return NOT_PRESENT; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_cvt_call_status | ++--------------------------------------------------------------------+ + + + PURPOSE : Request the call status. + +*/ + +T_MFW_CM_CALL_TYPE cm_cvt_call_mode( T_ACI_CAL_MODE type ) +{ +TRACE_EVENT_P1("cm_cnt_call_mode %d", type); + switch ( type ) + { + case ( CAL_MODE_Voice ): return VOICE_CALL; + case ( CAL_MODE_Data ): return DATA_CALL; + case ( CAL_MODE_Fax ): return FAX_CALL; + case (CAL_MODE_VFD_Voice): return VFD_VOICE; + case (CAL_MODE_VAD_Voice): return VAD_VOICE; + case (CAL_MODE_VAF_Voice): return VAF_VOICE; + case (CAL_MODE_VFD_Data): return VFD_DATA; + case (CAL_MODE_VAD_Data): return VAD_DATA; + case (CAL_MODE_VAF_Fax): return VAF_FAX; + default: return NONE_TYPE; + } +} + +T_MFW_CM_CALL_DIR cm_cvt_call_direction( T_ACI_CAL_TYPE type ) +{ +TRACE_EVENT_P1("cm_cvt_call_direction %d", type); + switch ( type ) + { + case ( CAL_TYPE_NotPresent): return MFW_CM_INV_DIR; + case ( CAL_TYPE_MOC): return MFW_CM_MOC; + case ( CAL_TYPE_MTC): return MFW_CM_MTC; + default: return MFW_CM_INV_DIR; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_status | ++--------------------------------------------------------------------+ + + + PURPOSE : Request the call status. + +*/ + +int cm_status(SHORT call_number, T_MFW_CM_STATUS *status, UBYTE num) +{ + UBYTE cnt; + int i; +// Apr 06 2005 REF: CRR 29989 xpradipg +// define and allocate memory +#ifdef FF_MMI_OPTIM + T_ACI_CAL_ENTR *call_tab;//[MAX_CALL_NR]; + call_tab = (T_ACI_CAL_ENTR*)mfwAlloc(sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); + if( NULL == call_tab) + return 0; +#endif + + + cnt = 0; + qAT_PercentCAL(CMD_SRC_LCL, call_tab); + + if (call_number > 0) + { + for (i=0; i<MAX_CALL_NR; i++) + { + if (call_tab[i].index == call_number) + { + status[0].call_number = call_tab[i].index; + status[0].stat = cm_cvt_call_status(call_tab[i].status); + status[0].type = cm_cvt_call_mode(call_tab[i].calMode); + status[0].mtpy = (T_MFW_MTPY_MEMBER)call_tab[i].mpty; + status[0].call_direction = cm_cvt_call_direction(call_tab[i].calType); + + if (call_tab[i].number != NULL) + { + mfwStrncpy((char *)status[0].number, call_tab[i].number, MFW_NUM_LEN); + status[0].ton = phb_cvtTon(call_tab[i].type.ton); + } + else + memset(status[0].number, '\0', MFW_NUM_LEN); + +#ifdef NO_ASCIIZ + status[0].name.len = call_tab[i].alpha.len; + if (call_tab[i].alpha.len) + memcpy(status[0].name.data, + call_tab[i].alpha.data, + call_tab[i].alpha.len); + else //We'll also zero the string. + memset(status[0].name.data, '\0', PHB_MAX_LEN); +#else + if (call_tab[i].alpha != NULL) + mfwStrncpy((char *)status[0].name, call_tab[i].alpha, MFW_TAG_LEN); + else + memset(status[0].name, '\0', MFW_TAG_LEN); +#endif + cnt = 1; + break; + } + } +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return cnt; + } + + if (!call_number) + { + for (i=0; i<MAX_CALL_NR; i++) + { + if ((call_tab[i].index EQ -1) OR cnt > num) + break; + + if (call_tab[i].status != CAL_STAT_NotPresent) + { + status[cnt].call_number = call_tab[i].index; + status[cnt].stat = cm_cvt_call_status(call_tab[i].status); + status[cnt].type = cm_cvt_call_mode(call_tab[i].calMode); + status[cnt].mtpy = (T_MFW_MTPY_MEMBER)call_tab[i].mpty; + if (call_tab[i].number != NULL) + { + mfwStrncpy((char *)status[cnt].number, call_tab[i].number, MFW_NUM_LEN); + status[cnt].ton = phb_cvtTon(call_tab[i].type.ton); + } + else + memset(status[cnt].number, '\0', MFW_NUM_LEN); + +#ifdef NO_ASCIIZ + status[cnt].name.len = call_tab[i].alpha.len; + if (call_tab[i].alpha.len != 0) + memcpy(status[cnt].name.data, + call_tab[i].alpha.data, + call_tab[i].alpha.len); + else //We'll also zero the string. + memset(status[cnt].name.data, '\0', PHB_MAX_LEN); +#else + if (call_tab[i].alpha != NULL) + mfwStrncpy((char *)status[cnt].name, call_tab[i].alpha, MFW_TAG_LEN); + else + memset(status[cnt].name, '\0', MFW_TAG_LEN); +#endif + cnt++; + } + } +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return cnt; + } +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocate memory +#ifdef FF_MMI_OPTIM + if(call_tab) + mfwFree((U8*)call_tab, sizeof(T_ACI_CAL_ENTR)*MAX_CALL_NR); +#endif + return 0; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_AT_CHLD | ++--------------------------------------------------------------------+ + + + PURPOSE : Notify the CHLD command + +*/ + +void cm_AT_CHLD(T_ACI_CLOG *clog_cmd) +{ + SHORT id; + #ifdef FF_ATI + T_ACI_CAL_MODE call_mode; + #endif + T_MFW_CM_STATUS status; + char buf[80]; + + TRACE_EVENT("cm_AT_CHLD()"); + + /*SPR#1965 - DS - Removed setting of call_number to zero. Port of 1962 + *dis_connect.call_number = 0; + */ + sprintf(buf, "dis_connect.call_number %d, cmd_hold %d, cId %d, srcId %d, mode %d, act %d", + dis_connect.call_number, cmd_hold, clog_cmd->cId, clog_cmd->cmdPrm.sCHLD.srcId, + clog_cmd->cmdPrm.sCHLD.mode, clog_cmd->cmdPrm.sCHLD.act); + TRACE_EVENT(buf); + + if ((clog_cmd->cmdPrm.sCHLD.act != CHLD_ACT_Retrieve) && + (clog_cmd->cmdPrm.sCHLD.act != CHLD_ACT_RetrieveMpty)) + { + /*SPR#1962 - DS - Set call_number to call Id returned from ACI */ + TRACE_EVENT("Set dis_connect.call_number to clog_cmd->cId"); + dis_connect.call_number = clog_cmd->cId; + } + else + { + dis_connect.call_number = -1; + } + if (clog_cmd->cmdPrm.sCHLD.srcId == CMD_SRC_LCL) + { + switch(clog_cmd->cmdPrm.sCHLD.mode) + { + case CHLD_MOD_RelHldOrUdub: + + if (cm_search_callId(CAL_STAT_DeactiveReq, &id) == CM_OK) + { + TRACE_FUNCTION("CAL_STAT_DeactiveReq - 0SEND"); + if ( cmd_hold EQ MFW_CM_1_SEND ) + { + TRACE_FUNCTION("cmd_hold EQ MFW_CM_1_SEND"); + cm_status(id, &status, 1); + if (status.mtpy EQ MFW_MTPY_MEMBER) + dis_connect.call_number = 0; + else + dis_connect.call_number = id; + } + } + + // Apr 26 2006, a0393213 (Prabakar R), OMAPS00074886 : No option in MMI to release the held call. + // cmd_hold variable is set to MFW_CM_TERMINATED to indicate that the call has been terminated + cmd_hold = MFW_CM_TERMINATED; + break; + + case CHLD_MOD_RelActAndAcpt: + + // MMI-SPR 13873 xkundadu + // Handling of 1+SEND - Releases all active calls (if any exist) and + // accepts the other (held or waiting) call. + + if( (cm_search_callId(CAL_STAT_DeactiveReq, &id) == CM_OK) OR + (cm_search_callId(CAL_STAT_Active, &id) == CM_OK)) + { + // If there is an active call/active call whose disconnection + // is initiated, store the index of that call. + dis_connect.call_number = id; + if(bIsMultpty == TRUE) + { + // Call is in multiparty + // 1SEND for multiparty will disconnect all the active calls + // To clear all calls assign the dis_connect.call_number to + // zero + dis_connect.call_number = 0; + bIsMultpty = FALSE; + } + } + else + { + // There is no active calls/active calls whose disconnection is + // iniated existing + dis_connect.call_number = -1; + } + if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK) + { + // Waiting call is existing. + // In the function cm_result_cmd(), value of cmd.call_number + // is used to determine whether to call cm_connect() or not + cmd.call_number=0; + } + cmd_hold = MFW_CM_1_SEND; + break; + + case CHLD_MOD_HldActAndAcpt: + + // MMI -SPR 13873 xkundadu + // Handling of 2+SEND - Places all active calls (if any exist) on hold + // and accepts the other (held or waiting) call. + + switch (clog_cmd->cmdPrm.sCHLD.act) + { + + case CHLD_ACT_Accept: + // Accept the incoming call + cmd_hold = MFW_CM_MT_ACCEPT; + break; + + case CHLD_ACT_Hold: + // Getting the id of the call which has been put on hold by ACI + cmd.command = CM_HOLD; + if (cm_search_callId(CAL_STAT_Held, &id) == CM_OK) + { + cmd.call_number = id; + } + else + { + cmd.call_number = -1; + } + break; + + case CHLD_ACT_Swap: + // Swap the call + cmd.command = CM_SWAP; + break; + + case CHLD_ACT_Retrieve: + // Getting the id of the call which has been made active by ACI + cmd.command = CM_RETRIEVE; + if (cm_search_callId(CAL_STAT_Active, &id) == CM_OK) + { + cmd.call_number = id; + } + else + { + cmd.call_number = -1; + } + break; + case CHLD_ACT_HoldMpty: + // Put the calls on HOLD + cmd.command = CM_HOLD_MULTIPARTY; + break; + + case CHLD_ACT_RetrieveMpty: + // Retrieve the held calls to active + cmd.command = CM_RETRIEVE_MULTIPARTY; + break; + + case CHLD_ACT_SwapMpty: + // Swap muliparty calls + cmd.command = CM_SWAP_MULTIPARTY; + break; + + default: + cmd.command = CM_COMMAND_UNKNOWN; + break; + + } + break; + case CHLD_MOD_RelActSpec: + dis_connect.call_number = (SHORT)atoi(clog_cmd->cmdPrm.sCHLD.call); + break; + + default: + break; + } + } + +// Aug 23, 2004 REF: CRR 22222 xkundadu +// Bug: Runaway Call Waiting Tone. +// Fix: Handle the AT-Command source id CMD_SRC_ATI_2 also for call control +// callback functions.Include source Id CMD_SRC_ATI_2 also for checking. + +//Nov 02, 2005 DR OMAPS00052132 xdeepadh +//The usage of ATI enum is put under the flag FF_ATI + +//Apr 21, 2006 OMAPS00070774 a0393213 (Prabakar R) +//Bug : Make MO call from MS1 to MS2. Make MT call from MS3 to MS1. Type at+chld=2 in ATI. +// expected behaviour : active call should be put to hold and the incoming call should be accepted +// observed behaviour : happens as expected. but display shows incoming call screen only. +// active screen is not shown eventhough the connection is established between MS1 and MS3 +//Fix : AT commands from CMD_SRC_ATI_3 was not processed. As a result, MFW was not informed of the acceptance of the call +//through ATI. In precise cmd_hold variable was not set to MFW_CM_MT_ACCEPT, which is necessary for display update + +#ifdef FF_ATI + if ((clog_cmd->cmdPrm.sCHLD.srcId == CMD_SRC_ATI_1) //NM Berlin UK integration + OR (clog_cmd->cmdPrm.sCHLD.srcId == CMD_SRC_ATI_2) // Added for MMI-SPR 22222 FIX + OR (clog_cmd->cmdPrm.sCHLD.srcId == CMD_SRC_ATI_3)) // Added for OMAPS00070774 FIX + { + switch(clog_cmd->cmdPrm.sCHLD.mode) + { + case CHLD_MOD_RelHldOrUdub: + if (clog_cmd->cmdPrm.sCHLD.act == CHLD_ACT_Release) + dis_connect.call_number = clog_cmd->cId; + cmd_hold = MFW_CM_TERMINATED; + break; + case CHLD_MOD_RelActAndAcpt: + switch (clog_cmd->cmdPrm.sCHLD.act) + { + case CHLD_ACT_Release: + dis_connect.call_number = clog_cmd->cId; + break; + case CHLD_ACT_Accept: + if (cm_search_callId(CAL_STAT_DeactiveReq, &id) == CM_OK) + dis_connect.call_number = id; + else if (cm_search_callId(CAL_STAT_Active, &id) == CM_OK) + { + call_mode = cm_search_callMode(id); + if (call_mode EQ CAL_MODE_Data + OR call_mode EQ CAL_MODE_Fax) + dis_connect.call_number = id; + } + if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK) + { + #ifdef MMI_LINT_WARNING_REMOVAL /*a0393213 lint warnings removal*/ + cc_id = id; + #endif + + //Apr 22, 2006 OMAPS00070762 a0393213 (Prabakar R) + //Bug : Make MO call from MS1 to MS2. Make MT call from MS3 to MS1. Type at+chld=1 in ATI. + //expected behaviour : active call should be released and the incoming call should be accepted + //observed behaviour : happens as expected. but display shows incoming call screen only. + // active screen is not shown eventhough the connection is established between MS1 and MS3 + //Fix : cmd.call_number was not set to 0, which is required in cm_result_cmd() + // to call cm_ok_connect()which updates the display. It's set. + cmd.call_number=0; + } + + break; + case CHLD_ACT_Retrieve: + if (cm_search_callId(CAL_STAT_Held, &id) == CM_OK) + { + cmd.command = CM_RETRIEVE; + cmd.call_number = id; + } + #ifdef MMI_LINT_WARNING_REMOVAL /*a0393213 lint warnings removal*/ + if (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK) + cc_id = id; + #else + cm_search_callId(CAL_STAT_Wait, &id); + #endif + break; + } + cmd_hold = MFW_CM_1_SEND; + break; + case CHLD_MOD_RelActSpec: + dis_connect.call_number = clog_cmd->cId; + if (dis_connect.call_number) + cmd_hold = MFW_CM_TERMINATED; + else + cmd_hold = MFW_CM_MPTY_TERMINATED; + break; + case CHLD_MOD_HldActAndAcpt: + switch (clog_cmd->cmdPrm.sCHLD.act) + { + case CHLD_ACT_Accept: + cmd_hold = MFW_CM_MT_ACCEPT; + break; + case CHLD_ACT_Hold: + cmd.command = CM_HOLD; + if (cm_search_callId(CAL_STAT_Held, &id) == CM_OK) + cmd.call_number = id; + else + cmd.call_number = -1; + break; + case CHLD_ACT_Swap: + cmd.command = CM_SWAP; + break; + case CHLD_ACT_Retrieve: + cmd.command = CM_RETRIEVE; + if (cm_search_callId(CAL_STAT_Active, &id) == CM_OK) + cmd.call_number = id; + else + cmd.call_number = -1; + break; + case CHLD_ACT_SwapMpty: + cmd.command = CM_SWAP_MULTIPARTY; + break; + case CHLD_ACT_HoldMpty: + cmd.command = CM_HOLD_MULTIPARTY; + break; + case CHLD_ACT_RetrieveMpty: + cmd.command = CM_RETRIEVE_MULTIPARTY; + break; + default: + cmd.command = CM_COMMAND_UNKNOWN; + break; + } + break; + case CHLD_MOD_HldActExc: + if (clog_cmd->cmdPrm.sCHLD.act == CHLD_ACT_SplitMpty) + cmd.command = CM_SPLIT_MULTIPARTY; + else + cmd.command = CM_COMMAND_UNKNOWN; + break; + case CHLD_MOD_AddHld: + if (clog_cmd->cmdPrm.sCHLD.act == CHLD_ACT_BuildMpty) + cmd.command = CM_RETRIEVE_MULTIPARTY; + else + cmd.command = CM_COMMAND_UNKNOWN; + break; + case CHLD_MOD_Ect: + cmd.command = CM_ETC; + break; + case CHLD_MOD_Ccbs: + TRACE_EVENT("CHLD_MOD_Ccbs"); + cmd.command = CM_CCBS; + break; + case CHLD_MOD_HldActDial: + cmd_hold = MFW_CM_HOLD_AND_DIAL; + cmd.command = CM_HOLD; + break; + default: + break; + } + } +#endif //FF_ATI +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_AT_D | ++--------------------------------------------------------------------+ + + + PURPOSE : Notify the outgoing call command. + +*/ + +void cm_AT_D(T_ACI_CLOG *cmd) +{ + SHORT index; + T_MFW_CM_CALL_STAT stat; + UBYTE ton; + UBYTE mode; +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +// Fix : Allocate the memory for entry and findText from heap instead of stack. +#ifdef FF_MMI_PB_OPTIM + T_MFW_PHB_ENTRY * entry = (T_MFW_PHB_ENTRY*)mfwAlloc(sizeof(T_MFW_PHB_ENTRY)); + T_MFW_PHB_TEXT * findText = (T_MFW_PHB_TEXT*)mfwAlloc(sizeof(T_MFW_PHB_TEXT)); +#else + T_MFW_PHB_ENTRY entry; + T_MFW_PHB_TEXT findText; +#endif + + TRACE_FUNCTION("cm_at_d()"); + +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +#ifdef FF_MMI_PB_OPTIM + #ifdef NO_ASCIIZ + entry->name.len = 0; + #else + memset (entry->name, '\0', MAX_LEN); + #endif + memset (entry->number, '\0', MAX_LEN); + entry->index = 0; + entry->npi = 0; + entry->ton = 0; + entries.entry = entry; +#else + #ifdef NO_ASCIIZ + entry.name.len = 0; + #else + memset (entry.name, '\0', MAX_LEN); + #endif + memset (entry.number, '\0', MAX_LEN); + entry.index = 0; + entry.npi = 0; + entry.ton = 0; + entries.entry = &entry; +#endif + + if (cmd->cmdPrm.sD.srcId == CMD_SRC_LCL) + { + out_call.call_id = cmd->cId; + mfwStrncpy((char *)out_call.number, cmd->cmdPrm.sD.number, MFW_NUM_LEN); + if (cc_stat.type == OUTGOING_CALL) + { + mfwStrncpy((char *)cc_stat.number, cmd->cmdPrm.sD.number, MFW_NUM_LEN); +#ifdef NO_ASCIIZ + cc_stat.name.len = 0; + out_call.name.len = 0; +#else + cc_stat.name[0] = '\0'; + out_call.name[0] = '\0'; +#endif + if (cm_search_callStat(cmd->cId, &stat, &ton, &mode) == CM_OK) + { + out_call.type = mode; +// Oct 10, 2006 DR: OMAPS00093720 x0039928 +// Fix: Set the cc_stat.ton info from out_call.ton + cc_stat.ton = out_call.ton; + cc_stat.mode = (T_MFW_CM_CALL_TYPE)mode; + } + +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +#ifdef NO_ASCIIZ + #ifdef FF_MMI_PB_OPTIM + mfwStrncpy((char *)findText->data, cmd->cmdPrm.sD.number, PHB_MAX_LEN); + findText->len = strlen(cmd->cmdPrm.sD.number); + #else + mfwStrncpy((char *)findText.data, cmd->cmdPrm.sD.number, PHB_MAX_LEN); + findText.len = strlen(cmd->cmdPrm.sD.number); + #endif + if (phb_find_entries (PHB_ADN, + &index, + MFW_PHB_NUMBER, + 1, + #ifdef FF_MMI_PB_OPTIM + findText, + #else + &findText, + #endif + &entries) EQ MFW_PHB_OK) + { + if (entries.num_entries) + { + cc_stat.name.len = entries.entry[0].name.len; + memcpy(cc_stat.name.data, + entries.entry[0].name.data, + entries.entry[0].name.len); + + out_call.name.len = entries.entry[0].name.len; + memcpy(out_call.name.data, + entries.entry[0].name.data, + entries.entry[0].name.len); + } + } +#else + if (phb_find_entries (PHB_ADN, + &index, + MFW_PHB_NUMBER, + 1, + cmd->cmdPrm.sD.number, + (T_MFW_PHB_LIST *)&entries) EQ MFW_PHB_OK) + { + if (entries.num_entries) + { + mfwStrncpy((char *)cc_stat.name, (char *)entries.entry[0].name, MFW_TAG_LEN); + mfwStrncpy((char *)out_call.name, (char *)entries.entry[0].name, PHB_MAX_LEN); + } + } +#endif + } + + if (cc_stat.type == REDIALING_CALL) + { +#ifdef NO_ASCIIZ + out_call.name.len = cc_stat.name.len; + memcpy(out_call.name.data, + cc_stat.name.data, + cc_stat.name.len); +#else + mfwStrncpy((char *)out_call.name, (char *)cc_stat.name, MFW_TAG_LEN); +#endif + out_call.type = cc_stat.mode; + } +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +// Fix: Free the dynamic memory allocated if flag FF_MMI_PB_OPTIM is defined + #ifdef FF_MMI_PB_OPTIM + mfwFree((U8*) entry, sizeof(T_MFW_PHB_ENTRY)); + mfwFree((U8*) findText, sizeof(T_MFW_PHB_TEXT)); + #endif + cm_signal(E_CM_MO_RES, &out_call); + } + else if (cmd->cmdPrm.sD.srcId < CMD_SRC_MAX) + { + //x0pleela 03 Nov, 2006 DR: OMAPS00101158 + //set the value of uOthersrc to TRUE as the source id is not LOCAL + mfw_set_OtherSrc_Value(TRUE); + out_call.call_id = cmd->cId; + mfwStrncpy((char *)out_call.number, (char *)cmd->cmdPrm.sD.number, MFW_NUM_LEN); +#ifdef NO_ASCIIZ + out_call.name.len = 0; +#else + out_call.name[0] = '\0'; +#endif + if (cm_search_callStat(cmd->cId, &stat, &ton, &mode) == CM_OK) + { + out_call.type = mode; + } + //x0pleela 03 Nov, 2006 DR: OMAPS00101158 + //check the value of uOthersrc + //If the value is not set then do the phone book search operation + //Else do not perform phone book search operation + //this is to avoid stack overflow probelm when the source id is not LOCAL + if(!mfw_get_OtherSrc_Value())//x0pleela 3 nov 2006 + { +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +#ifdef NO_ASCIIZ + #ifdef FF_MMI_PB_OPTIM + mfwStrncpy((char *)findText->data, cmd->cmdPrm.sD.number, PHB_MAX_LEN); + findText->len = strlen(cmd->cmdPrm.sD.number); + #else + mfwStrncpy((char *)findText.data, cmd->cmdPrm.sD.number, PHB_MAX_LEN); + findText.len = strlen(cmd->cmdPrm.sD.number); + #endif + if (phb_find_entries (PHB_ADN, + &index, + MFW_PHB_NUMBER, + 1, + #ifdef FF_MMI_PB_OPTIM + findText, + #else + &findText, + #endif + &entries) EQ MFW_PHB_OK) + { + if (entries.num_entries) + { + out_call.name.len = entries.entry[0].name.len; + memcpy(out_call.name.data, + entries.entry[0].name.data, + entries.entry[0].name.len); + } + } +#else + if (phb_find_entries (PHB_ADN, + &index, + MFW_PHB_NUMBER, + 1, + cmd->cmdPrm.sD.number, + (T_MFW_PHB_LIST *)&entries) EQ MFW_PHB_OK) + { + if (entries.num_entries) + { + mfwStrncpy((char *)out_call.name, (char *)entries.entry[0].name, MFW_TAG_LEN); + } + } +#endif + } //3 +// Sep 01, 2006 REF:OMAPS00090555 x0039928 +// Fix: Free the dynamic memory allocated if flag FF_MMI_PB_OPTIM is defined + #ifdef FF_MMI_PB_OPTIM + mfwFree((U8*) entry, sizeof(T_MFW_PHB_ENTRY)); + mfwFree((U8*) findText, sizeof(T_MFW_PHB_TEXT)); + #endif + cm_signal(E_CM_MO_RES, &out_call); + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_cvtCPItype | ++--------------------------------------------------------------------+ + + + PURPOSE : Convert the type of + +*/ + +T_MFW_CPI_TYPE cm_cvtCPItype(T_ACI_CPI_MSG msg) +{ + switch (msg) + { + case CPI_MSG_Setup: return CPI_TYPE_SETUP; + case CPI_MSG_Disc: return CPI_TYPE_DISC; + case CPI_MSG_Alert: return CPI_TYPE_ALERT; + case CPI_MSG_Proc: return CPI_TYPE_PROC; + case CPI_MSG_Sync: return CPI_TYPE_SYNC; + case CPI_MSG_Conn: return CPI_TYPE_CONN; + /* CQ11676 Added new messages types in CPi indication. 17-02-04 MZ */ + #ifndef FF_2TO1_PS + case CPI_MSG_Rls: return CPI_TYPE_RELEASE; + case CPI_MSG_Rjct: return CPI_TYPE_REJECT; + #endif + default: return CPI_TYPE_UNKNOWN; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_cvtIBT | ++--------------------------------------------------------------------+ + + + PURPOSE : Convert in-band tones indication + +*/ + +T_MFW_CPI_IBT cm_cvtIBT(T_ACI_CPI_IBT ibt) +{ + switch (ibt) + { + case CPI_IBT_False: return CPI_IBT_FALSE; + case CPI_IBT_True: return CPI_IBT_TRUE; + default: return CPI_IBT_UNKNOWN; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_cvtTCH | ++--------------------------------------------------------------------+ + + + PURPOSE : Convert traffic channel indication + +*/ + +T_MFW_CPI_TCH cm_cvtTCH(T_ACI_CPI_TCH tch) +{ + switch (tch) + { + case CPI_TCH_False: return CPI_TCH_FALSE; + case CPI_TCH_True: return CPI_TCH_TRUE; + default: return CPI_TCH_UNKNOWN; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: rAT_PercentCPI | ++--------------------------------------------------------------------+ + + + PURPOSE : Call Progress Information + +*/ +// ADDED BY RAVI - FOR ACI CHANGES - 5-10-2005 +#if (defined(FF_2TO1_PS) && BOARD != 61) +void rAT_PercentCPI(SHORT cId, + T_ACI_CPI_MSG msgType, + T_ACI_CPI_IBT ibt, + T_ACI_CPI_TCH tch) + +{ + cm_cpi.call_number = cId; + cm_cpi.type = cm_cvtCPItype(msgType); + cm_cpi.inband = cm_cvtIBT(ibt); + cm_cpi.tch = cm_cvtTCH(tch); +// cm_cpi.cause = CPI_CAUSE_MASK & cause; /* cq11676 Add cause information to the CPI indication 17-02-04 MZ */ + cm_signal(E_CM_CPI, &cm_cpi); +} +#else +void rAT_PercentCPI(SHORT cId, + T_ACI_CPI_MSG msgType, + T_ACI_CPI_IBT ibt, + T_ACI_CPI_TCH tch, + USHORT cause ) /*cq11676 Add cause parameter for cpi indication 17-02-04 MZ */ +{ + cm_cpi.call_number = cId; + cm_cpi.type = cm_cvtCPItype(msgType); + cm_cpi.inband = cm_cvtIBT(ibt); + cm_cpi.tch = cm_cvtTCH(tch); + cm_cpi.cause = CPI_CAUSE_MASK & cause; /* cq11676 Add cause information to the CPI indication 17-02-04 MZ */ + cm_signal(E_CM_CPI, &cm_cpi); +} +#endif +// END OF ADDITION - RAVI - 5-10-2005. + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_error_code | ++--------------------------------------------------------------------+ + + + PURPOSE : + +*/ + +UBYTE cm_error_code(T_ACI_AT_CMD cmd) +{ + ULONG err; + + err = qAT_ErrDesc(); + switch (ACI_ERR_DESC_CLASS( err )) + { + case ACI_ERR_CLASS_Cme: + break; + case ACI_ERR_CLASS_Cms: + break; + case ACI_ERR_CLASS_Ceer: + switch (ACI_ERR_DESC_NR( err )) + { + case CEER_ACM_Max: return CM_ACM_MAX; + default: return CM_ERROR; + } +// break; // RAVI + case ACI_ERR_CLASS_Ext: + switch (ACI_ERR_DESC_NR( err )) + { + case EXT_ERR_FdnCheck: return CM_CFDN_ERR; + case EXT_ERR_BdnCheck: return CM_CBDN_ERR; + case EXT_ERR_OneCallOnHold: return CM_2CALLS_ALREADY_ERR; + //xvilliva 21421 - Handling err code returned by ACI. +#ifndef FF_2TO1_PS + case EXT_ERR_AlsLock: return CM_ALS_ERR; +#endif + default: return CM_ERROR; + } + // break; // RAVI + default: + break; + } + return CM_ERROR; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_bc_parameter | ++--------------------------------------------------------------------+ + + + PURPOSE : Notice bearer service parameter + +*/ +/*a0393213 warnings removal - parameter changed as a result of ACI enum change*/ +void cm_bc_parameter(T_ACI_CRING_SERV_TYP type) +{ + TRACE_FUNCTION("cm_cvt_cringType()"); + + switch (type) + { + case CRING_SERV_TYP_Voice: + break; + case CRING_SERV_TYP_Fax: + in_call.bc1.conn_elem = Transparent; + break; + case CRING_SERV_TYP_Sync: + in_call.bc1.bearer_serv = Synch; + in_call.bc1.conn_elem = Transparent; + break; + case CRING_SERV_TYP_Async: + in_call.bc1.bearer_serv = Asynch; + in_call.bc1.conn_elem = Transparent; + break; + case CRING_SERV_TYP_RelSync: + in_call.bc1.bearer_serv = Synch; + in_call.bc1.conn_elem = NonTransparent; + break; + case CRING_SERV_TYP_RelAsync: + in_call.bc1.bearer_serv = Asynch; + in_call.bc1.conn_elem = NonTransparent; + break; + default: + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cm_build_callType | ++--------------------------------------------------------------------+ + + + PURPOSE : + +*/ +/*a0393213 warnings removal - parameters type changed as a result of ACI enum change*/ +void cm_build_callType(T_ACI_CRING_SERV_TYP type1, T_ACI_CRING_SERV_TYP type2) +{ + if (type1 EQ CRING_SERV_TYP_Voice) + { + switch (type2) + { + case CRING_SERV_TYP_Sync: + case CRING_SERV_TYP_Async: + case CRING_SERV_TYP_RelSync: + case CRING_SERV_TYP_RelAsync: + in_call.type = VAD_VOICE; + return; + case CRING_SERV_TYP_Fax: + in_call.type = VAF_VOICE; + return; + default: + break; + } + } + if (type2 EQ CRING_SERV_TYP_Voice) + { + switch (type1) + { + case CRING_SERV_TYP_Sync: + case CRING_SERV_TYP_Async: + case CRING_SERV_TYP_RelSync: + case CRING_SERV_TYP_RelAsync: + in_call.type = VAD_DATA; + return; + case CRING_SERV_TYP_Fax: + in_call.type = VAF_FAX; + return; + default: + break; + } + } + in_call.type = NONE_TYPE; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_CM | +| STATE : code ROUTINE : cmCommand | ++--------------------------------------------------------------------+ + + PURPOSE : handle mfw windows command + +*/ + +static int cmCommand (U32 cmd, void *h) +{ + switch (cmd) + { + case MfwCmdDelete: /* delete me */ + if (!h) + return 0; + cm_delete(h); + return 1; + default: + break; + } + + return 0; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_command_abort | ++--------------------------------------------------------------------+ + + + PURPOSE : + +*/ + +T_MFW cm_command_abort(UBYTE command) +{ + TRACE_FUNCTION ("cm_command()"); + + switch (command) + { + case CM_HOLD: + case CM_SWAP: + case CM_RETRIEVE: + case CM_SWAP_MULTIPARTY: + case CM_HOLD_MULTIPARTY: + case CM_RETRIEVE_MULTIPARTY: + case CM_BUILD_MULTIPARTY: + case CM_SPLIT_MULTIPARTY: + case CM_ETC: + case CM_CCBS: + sAT_Abort(CMD_SRC_LCL, AT_CMD_CHLD); + break; + + case CM_DTMF_ACTIVE: + case CM_DTMF_INACTIVE: + case CM_DTMF_AUTO: + sAT_Abort(CMD_SRC_LCL, AT_CMD_VTS); + break; + + default: + return FALSE; + } + return TRUE; +} + +/* Marcus: CCBS: 13/11/2002: Start */ +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_ccbs_delete_all | ++--------------------------------------------------------------------+ + + PURPOSE : Delete all registered CCBS + + Returns: T_MFW: CM_OK if successful, CM_ERROR if not + + Arguments: None +*/ +T_MFW cm_ccbs_delete_all(void) +{ + T_MFW res = CM_ERROR; // The value to be returned by this function + T_ACI_RETURN aci_res; // The value returned by sAT_PercentCCBS + + TRACE_FUNCTION("cm_ccbs_delete_all()"); + + if (ccbs_op == CM_CCBS_NONE) + { + TRACE_EVENT("ccbs_op == CM_CCBS_NONE"); + /* No CCBS operation currently in progress */ +#ifndef CCBS_TEST + aci_res = sAT_PercentCCBS(CMD_SRC_LCL, 0); +#else + aci_res = AT_EXCT; +#endif + if (aci_res == AT_EXCT) + { + TRACE_EVENT("sAT_PercentCCBS returned AT_EXCT"); + ccbs_op = CM_CCBS_DELETE_ALL; + res = CM_OK; + } + else + { + TRACE_EVENT_P1("sAT_PercentCCBS returned %d", aci_res); + } + } + else + { + TRACE_EVENT_P1("ccbs_op is %d", ccbs_op); + } + + return res; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_ccbs_delete | ++--------------------------------------------------------------------+ + + PURPOSE : Delete a specific registered CCBS + + Returns: T_MFW: CM_OK if successful, CM_ERROR if not + + Arguments: SHORT idx: the index to the specific CCBS to be deleted +*/ +T_MFW cm_ccbs_delete(SHORT idx) +{ + T_MFW res = CM_ERROR; // The value to be returned by this function + T_ACI_RETURN aci_res; // The value returned by sAT_PercentCCBS + + TRACE_FUNCTION("cm_ccbs_delete()"); + TRACE_EVENT_P1("deleting CCBS %d", idx); + + if (ccbs_op == CM_CCBS_NONE) + { + TRACE_EVENT("ccbs_op == CM_CCBS_NONE"); + /* No CCBS operation currently in progress */ +#ifndef CCBS_TEST + aci_res = sAT_PercentCCBS(CMD_SRC_LCL, idx); +#else + aci_res = AT_EXCT; +#endif + if (aci_res == AT_EXCT) + { + TRACE_EVENT("sAT_PercentCCBS returned AT_EXCT"); + ccbs_op = CM_CCBS_DELETE; + res = CM_OK; + } + else + { + TRACE_EVENT_P1("sAT_PercentCCBS returned %d", aci_res); + } + } + else + { + TRACE_EVENT_P1("ccbs_op is %d", ccbs_op); + } + + return res; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_ccbs_list | ++--------------------------------------------------------------------+ + + PURPOSE : Delete all registered CCBS + + Returns: T_MFW: CM_OK if successful, CM_ERROR if not + + Arguments: None +*/ +T_MFW cm_ccbs_list(void) +{ + T_MFW res = CM_ERROR; // The value to be returned by this function + T_ACI_RETURN aci_res; // The value returned by qAT_PercentCCBS + + TRACE_FUNCTION("cm_ccbs_list()"); + + if (ccbs_op == CM_CCBS_NONE) + { + /* No CCBS operation currently in progress */ + TRACE_EVENT("ccbs_op == CM_CCBS_NONE"); +#ifndef CCBS_TEST + aci_res = qAT_PercentCCBS(CMD_SRC_LCL); +#else + aci_res = AT_EXCT; +#endif + if (aci_res == AT_EXCT) + { + TRACE_EVENT("qAT_PercentCCBS returned AT_EXCT"); + ccbs_op = CM_CCBS_LIST; + res = CM_OK; + } + else + { + TRACE_EVENT_P1("qAT_PercentCCBS returned %d", aci_res); + } + } + else + { + TRACE_EVENT_P1("ccbs_op is %d", ccbs_op); + } + + return res; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_ccbs_accept_registration | ++--------------------------------------------------------------------+ + + PURPOSE : Accepts the CCBS registration being offered + + Returns: T_MFW: CM_OK if successful, CM_ERROR if not + + Arguments: None +*/ +T_MFW cm_ccbs_accept_registration(void) +{ + T_MFW res = CM_ERROR; // The value to be returned by this function + T_ACI_RETURN aci_res; // The value returned by sAT_PlusCHLD + + TRACE_FUNCTION("cm_ccbs_accept_registration()"); + + if (ccbs_op == CM_CCBS_NONE) + { + /* No CCBS operation currently in progress */ + TRACE_EVENT("ccbs_op == CM_CCBS_NONE"); + cm_set_cmd_status(CHLD_MOD_Ccbs, ""); + cmd_hold = MFW_CM_CCBS_REGISTER; +#ifndef CCBS_TEST + aci_res = sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_Ccbs, NULL); +#else + aci_res = AT_EXCT; +#endif + if (aci_res == AT_EXCT) + { + TRACE_EVENT("sAT_PlusCHLD returned AT_EXCT"); + ccbs_op = CM_CCBS_ACCEPT_REGISTRATION; + res = CM_OK; + } + else + { + TRACE_EVENT_P1("sAT_PlusCHLD returned %d", aci_res); + } + } + else + { + TRACE_EVENT_P1("ccbs_op is %d", ccbs_op); + } + + return res; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_ccbs_reject_registration | ++--------------------------------------------------------------------+ + + PURPOSE : Rejects the CCBS registration being offered + + Returns: T_MFW: CM_OK if successful, CM_ERROR if not + + Arguments: None +*/ +T_MFW cm_ccbs_reject_registration(void) +{ + T_MFW res = CM_ERROR; // The value to be returned by this function + T_ACI_RETURN aci_res; // The value returned by sAT_H + + TRACE_FUNCTION("cm_ccbs_reject_registration()"); + + if (ccbs_op == CM_CCBS_NONE) + { + /* No CCBS operation currently in progress */ + TRACE_EVENT("ccbs_op == CM_CCBS_NONE"); + cmd_hold = MFW_CM_CCBS_REGISTER; +#ifndef CCBS_TEST + aci_res = sAT_H(CMD_SRC_LCL); +#else + aci_res = AT_EXCT; +#endif + if (aci_res == AT_EXCT) + { + TRACE_EVENT("sAT_H returned AT_EXCT"); + ccbs_op = CM_CCBS_REJECT_REGISTRATION; + res = CM_OK; + } + else + { + TRACE_EVENT_P1("sAT_H returned %d", aci_res); + } + } + else + { + TRACE_EVENT_P1("ccbs_op is %d", ccbs_op); + } + + return res; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_ccbs_accept_recall | ++--------------------------------------------------------------------+ + + PURPOSE : Accepts the CCBS recall being offered + + Returns: T_MFW: CM_OK if successful, CM_BLACKIST or CM_ERROR if not + + Arguments: UBYTE *number - the number of the phone to call + T_MFW_CM_CALL_TYPE type - the type of the call to be made +*/ +T_MFW cm_ccbs_accept_recall(UBYTE *number, T_MFW_CM_CALL_TYPE type) +{ + T_MFW res = CM_ERROR; // The value to be returned by this function + /*a0393213 compiler warnings removal -- removed def of search_res*/ + T_ACI_RETURN aci_res; // The value returned by sAT_PlusCHLD + SHORT call_number;// The call identity of any held call + UBYTE phone[MFW_NUM_LEN]; // Working copy of phone number + // CHAR *rest; // Parameter for ss_decode // RAVI +// T_KSD_SEQPARAM para; // Parameter for ss_decode // RAVI +// T_MFW_SS_RETURN ss_res; // The value returned by ss_decode // RAVI + + TRACE_FUNCTION("cm_ccbs_accept_recall()"); + + if (ccbs_op == CM_CCBS_NONE) + { + /* No CCBS operation currently in progress */ + TRACE_EVENT("ccbs_op == CM_CCBS_NONE"); + /* Ensure the number given is an ASCIIZ string thet is not too long */ + mfwStrncpy((char *)phone, (char *)number, MFW_NUM_LEN); + TRACE_EVENT_P1("ccbs nr: %s", phone); + + /* Make sure that it is OK to call this number */ + if ((res = cm_check_mo_number(phone)) == CM_OK) + { + TRACE_EVENT("cm_check_mo_number returned CM_OK"); + /* Set up data as for mobile originated call */ + cm_set_call_mode(type); + call_stat = OUTGOING_CALL; + redial_count = 0; + cc_stat.type = OUTGOING_CALL; + currConnecting = 1; + + if ((cm_search_callId(CAL_STAT_Held, &call_number)) == CM_OK) + { + TRACE_EVENT("Held call: CHLD_MOD_RelActAndAcpt"); + /* There is a held call: release active call and accept callback */ + cm_set_cmd_status(CHLD_MOD_RelActAndAcpt, ""); +#ifndef CCBS_TEST + aci_res = sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_RelActAndAcpt, NULL); +#else + aci_res = AT_EXCT; +#endif + } + else + { + TRACE_EVENT("No held call: CHLD_MOD_HldActAndAcpt"); + /* There is no held call: hold any active call and accept callback */ + cm_set_cmd_status(CHLD_MOD_HldActAndAcpt, ""); +#ifndef CCBS_TEST + aci_res = sAT_PlusCHLD(CMD_SRC_LCL, CHLD_MOD_HldActAndAcpt, NULL); +#else + aci_res = AT_EXCT; +#endif + } + + cmd_hold = MFW_CM_CCBS_RECALL; + + if (aci_res == AT_EXCT) + { + TRACE_EVENT("sAT_PlusCHLD returned AT_EXCT"); + ccbs_op = CM_CCBS_ACCEPT_RECALL; + res = CM_OK; + } + else + { + /* The attempt to accept the callback failed */ + TRACE_EVENT_P1("sAT_PlusCHLD returned %d", aci_res); + call_stat = MFW_CALL_FREE; + } + } + else + { + /* It is not OK to call this number for some reason */ + TRACE_EVENT_P1("cm_check_mo_number returned %d", res); + } + } + else + { + TRACE_EVENT_P1("ccbs_op is %d", ccbs_op); + } + + return res; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_ccbs_reject_recall | ++--------------------------------------------------------------------+ + + PURPOSE : Rejects the CCBS recall being offered + + Returns: T_MFW: CM_OK if successful, CM_ERROR if not + + Arguments: None +*/ +T_MFW cm_ccbs_reject_recall(void) +{ + T_MFW res = CM_ERROR; // The value to be returned by this function + T_ACI_RETURN aci_res; // The value returned by sAT_PlusCHLD + + TRACE_FUNCTION("cm_ccbs_reject_recall()"); + + if (ccbs_op == CM_CCBS_NONE) + { + /* No CCBS operation currently in progress */ + TRACE_EVENT("ccbs_op == CM_CCBS_NONE"); + cm_set_cmd_status(CHLD_MOD_RelHldOrUdub, ""); + cmd_hold = MFW_CM_CCBS_RECALL; + +#ifndef CCBS_TEST + aci_res = sAT_H(CMD_SRC_LCL); +#else + aci_res = AT_CMPL; +#endif + if (aci_res == AT_CMPL) + { + TRACE_EVENT("sAT_H returned AT_CMPL"); + ccbs_op = CM_CCBS_REJECT_RECALL; + res = CM_OK; + } + else + { + TRACE_EVENT_P1("sAT_H returned %d", aci_res); + } + } + else + { + TRACE_EVENT_P1("ccbs_op is %d", ccbs_op); + } + + return res; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_ccbs_ok | ++--------------------------------------------------------------------+ + + PURPOSE : Called by rAT_OK for "OK" result code for %CCBS command + + Returns: Nothing + + Arguments: None +*/ +void cm_ccbs_ok(void) +{ + TRACE_FUNCTION("cm_ccbs_ok()"); + + memset((void *)&ccbs_info, 0, sizeof(ccbs_info)); + + ccbs_info.operation = ccbs_op; + ccbs_op = CM_CCBS_NONE; + ccbs_info.type = CM_CCBS_OK; + + TRACE_EVENT_P2("E_CM_CCBS: op = %d: type = %d", + ccbs_info.operation, ccbs_info.type); + + cm_signal(E_CM_CCBS, &ccbs_info); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_ccbs_error | ++--------------------------------------------------------------------+ + + PURPOSE : Called by rAT_PlusCME for "+CME error" result code for %CCBS command + + Returns: Nothing + + Arguments: None +*/ +void cm_ccbs_error(void) +{ + TRACE_FUNCTION("cm_ccbs_error()"); + + memset((void *)&ccbs_info, 0, sizeof(ccbs_info)); + + ccbs_info.operation = ccbs_op; + ccbs_op = CM_CCBS_NONE; + ccbs_info.type = CM_CCBS_ERROR; + + TRACE_EVENT_P2("E_CM_CCBS: op = %d: type = %d", + ccbs_info.operation, ccbs_info.type); + + cm_signal(E_CM_CCBS, &ccbs_info); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: rAT_PercentCCBS | ++--------------------------------------------------------------------+ + + PURPOSE : Called by ACI for "%CCBS:" result code + + Returns: Nothing + + Arguments: T_ACI_CCBS_IND indct - type of %CCBS indication + T_ACI_CCBS_STAT status - status of %CCBS indication + T_ACI_CCBS_SET *setting - optiona parameters of %CCBS indication +*/ +void rAT_PercentCCBS( T_ACI_CCBS_IND indct, + T_ACI_CCBS_STAT status, + T_ACI_CCBS_SET *setting ) +{ + TRACE_FUNCTION("rAT_PercentCCBS()"); + TRACE_EVENT_P3("indct = %d: status = %d: setting = %p", indct, status, setting); + + memset((void *)&ccbs_info, 0, sizeof(ccbs_info)); + + /* Fill in the fields of the E_CM_CCBS event structure */ + switch (indct) + { + case CCBS_IND_Possible: + case CCBS_IND_Recall: + case CCBS_IND_PossibilityTimedOut: + case CCBS_IND_RecallTimedOut: + + /* An asynchronous %CCBS, not in response to a %CCBS command */ + TRACE_EVENT("Unsolicited event"); + ccbs_info.operation = CM_CCBS_ASYNC; + break; + + default: + TRACE_EVENT("Solicited event"); + ccbs_info.operation = ccbs_op; + break; + } + + ccbs_info.type = CM_CCBS_INFO; + ccbs_info.indct = indct; + ccbs_info.status = status; + + TRACE_EVENT_P2("E_CM_CCBS: op = %d: type = %d", + ccbs_info.operation, ccbs_info.type); + TRACE_EVENT_P2(" indct = %d: status = %d", + ccbs_info.indct, ccbs_info.status); + + if (setting == (T_ACI_CCBS_SET *) NULL) + { + /* No T_ACI_CCBS_SET structure given. Indicate in the idx field of ccbs_info */ + TRACE_EVENT("setting == NULL"); + ccbs_info.idx = 0; + } + else + { + /* T_ACI_CCBS_SET structure given. Fill in the remaining field of ccbs_info */ + TRACE_EVENT("setting != NULL"); + ccbs_info.idx = setting->idx; + strncpy((char *) ccbs_info.number, (char *) setting->number, sizeof(ccbs_info.number)-1); + ccbs_info.number[sizeof(ccbs_info.number)-1] = '\0'; + ccbs_info.ton = phb_cvtTon(setting->type.ton); + ccbs_info.call_type = cm_callTyp_cvt(setting->class_type); + strncpy((char *) ccbs_info.subaddr, (char *) setting->subaddr, sizeof(ccbs_info.subaddr)-1); + ccbs_info.subaddr[sizeof(ccbs_info.subaddr)-1] = '\0'; + ccbs_info.alrtPtn = setting->alrtPtn; + TRACE_EVENT_P3(" idx = %d: number = %s: ton = %d", + ccbs_info.idx, ccbs_info.number, ccbs_info.ton); + TRACE_EVENT_P3(" call_type = %d: subaddr = %s: alrtPtn = %d", + ccbs_info.call_type, ccbs_info.subaddr, ccbs_info.alrtPtn); + } + + cm_signal(E_CM_CCBS, &ccbs_info); +} + +/* Marcus: CCBS: 13/11/2002: End */ + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_error_dial | ++--------------------------------------------------------------------+ + + + PURPOSE : The call setup is not successful + +*/ + +void cm_error_dial(T_ACI_CME_ERR err) +{ + TRACE_FUNCTION("cm_error_dial()"); + + switch (err) + { + case CME_ERR_OpNotAllow: /* the active call can not be hold */ + /* allow a new outgoing */ + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + cmd.command = CM_HOLD; + if (cm_search_callId(CAL_STAT_Active, &cmd.call_number) NEQ CM_OK) + cmd.call_number = -1; + cmd.result = NotPresent; + cm_signal(E_CM_COMMAND, &cmd); + break; + + /*SPR#2235 - DS - If handset is powered-up without a SIM and an emergency + *call is attempted, the UK networks will reject the call attempt. Send a signal to + *the BMI to enable it to destroy the call and show an appropriate error message. + * + *The ACI calls rAT_PlusCME() - then rAT_PlusCME() calls this funct - for this SIM + *failure but the ACI doesn't supply the callId. Without the callId, the MFW/BMI + *cannot close down the call properly. The ACI interface will need to be changed + *so that it supplies the callId (if there is an active call) when this failure occurs. + */ + case CME_ERR_SimFail: + /* allow a new outgoing */ + call_stat = MFW_CALL_FREE; + call_type = MFW_CALL_FREE; + + /*SPR#2235 - DS - Fake the callId. Workaround needed until the ACI interface is changed */ + cm_error_connect(1); + break; + + default: + TRACE_EVENT_P1("Error code: %d. No signal sent.", err); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_data_connect | ++--------------------------------------------------------------------+ + + + PURPOSE : Fax/Data connect + +*/ + +void cm_data_connect(SHORT callId) +{ + SHORT call_number; + + TRACE_FUNCTION("cm_data_connect()"); + + call_number = callId; + cm_signal(E_CM_CONNECT, &call_number); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_data_connect | ++--------------------------------------------------------------------+ + + + PURPOSE : Fax/Data connect + +*/ + +void cm_wap_data_connected(void) +{ + // SHORT call_number; // RAVI + + TRACE_FUNCTION("cm_wap_data_connected()"); + + cm_signal(E_CM_WAP_CALL_CONNECTED, NULL); +} +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_deflect_incoming_call | ++--------------------------------------------------------------------+ + + + PURPOSE : try to deflect a call using AT command CTFR + +*/ +T_MFW cm_deflect_incoming_call(char* number) +{ T_ACI_RETURN result; + T_ACI_TOA type; + T_ACI_TOS subaddr_type; + + type.ton = TON_Unknown; + type.npi = NPI_Unknown; + + subaddr_type.tos = TOS_NotPresent; + subaddr_type.oe = OE_NotPresent; + + result = sAT_PlusCTFR(CMD_SRC_LCL, number, &type, NULL, &subaddr_type); + + if ((result == AT_BUSY) || (result == AT_FAIL)) + return FALSE; + return TRUE; + +} +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_ok_CTFR | ++--------------------------------------------------------------------+ + + + PURPOSE : sends call deflect OK event to MMI + +*/ +void cm_ok_CTFR(void) +{ BOOL status = TRUE; + + cm_signal(E_CM_CALL_DEFLECT_STATUS, &status); + +} +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_error_CTFR | ++--------------------------------------------------------------------+ + + + PURPOSE : Sends call deflect failed event to MMI + +*/ +void cm_error_CTFR(void) +{ + BOOL status = FALSE; + + cm_signal(E_CM_CALL_DEFLECT_STATUS, &status); +} +#ifdef CCBS_TEST +/* Marcus: CCBS testing: 20/11/2002: Start */ +static void strlower(char *string) +{ + while(*string) + { + *string = (char)tolower((int) *string); + string++; + } +} + +static BOOL getCmdId(char *token, T_ACI_AT_CMD *cmdId) +{ + BOOL cmdIdOk = FALSE; + TRACE_FUNCTION("getCmdId()"); + if (token) + { + strlower(token); + TRACE_EVENT_P1("token: %s", token); + if (strstr(token, "ccbs")) + { + *cmdId = AT_CMD_CCBS; + cmdIdOk = TRUE; + } + else if (strstr(token, "chld")) + { + *cmdId = AT_CMD_CHLD; + cmdIdOk = TRUE; + } + else if (strcmp("h", token) == 0) + { + *cmdId = AT_CMD_H; + cmdIdOk = TRUE; + } + else if ((*cmdId = atoi(token))) + { + cmdIdOk = TRUE; + } + } + else + { + TRACE_EVENT("No token"); + } + + return cmdIdOk; +} +#endif + +#if defined MFW & defined TI_PS_FF_AT_P_CMD_MMITEST +void rAT_PercentMMITEST(char *param) +{ + char work[80]; +#ifdef CCBS_TEST /*a0393213 compiler warning removal. 'token' removed conditionally*/ + char *token; // Current token obtained from strtok +#endif + TRACE_FUNCTION("rAT_PercentMMITEST()"); + + strncpy(work, param, sizeof(work)-1); + work[sizeof(work)-1] = '\0'; + +#ifdef CCBS_TEST + if ((token = strtok(work, ",()")) != NULL) +#else + if (strtok(work, ",()") != NULL) +#endif + { +#ifdef CCBS_TEST + T_ACI_AT_CMD cmdId; + strlower(token); + TRACE_EVENT_P1("token: %s", token); + + if (strcmp("ok", token) == 0) + { + TRACE_EVENT("OK"); + if ((token = strtok(NULL, ",()")) != NULL) + { + if (getCmdId(token, &cmdId) == TRUE) + { + TRACE_EVENT_P1("rAT_OK(cmdId = %d", cmdId); + rAT_OK(cmdId); + } + else + { + TRACE_EVENT("Unknown cmdId"); + } + } + else + { + TRACE_EVENT("No cmdId token"); + } + } + else if (strcmp("error", token) == 0) + { + TRACE_EVENT("ERROR"); + if ((token = strtok(NULL, ",()")) != NULL) + { + if (getCmdId(token, &cmdId) == TRUE) + { + T_ACI_CME_ERR err; + if ((token = strtok(NULL, ",()")) != NULL) + { + err = atoi(token); + rAT_PlusCME(cmdId, err); + } + else + { + TRACE_EVENT("No err token"); + } + } + } + else + { + TRACE_EVENT("No cmdId token"); + } + } + else if (strcmp("info", token) == 0) + { + T_ACI_CCBS_IND indct = CCBS_IND_NotPresent; + T_ACI_CCBS_STAT status = CCBS_STAT_NotPresent; + T_ACI_CCBS_SET setting, *pSetting = NULL; + TRACE_EVENT("INFO"); + if ((token = strtok(NULL, ",()")) != NULL) + { + strlower(token); + TRACE_EVENT_P1("token: %s", token); + if (strstr(token, "notpresent")) + indct = CCBS_IND_NotPresent; + else if (strstr(token, "possibility")) + indct = CCBS_IND_PossibilityTimedOut; + else if (strstr(token, "possible")) + indct = CCBS_IND_Possible; + else if (strstr(token, "registered")) + indct = CCBS_IND_Registered; + else if (strstr(token, "recallt")) + indct = CCBS_IND_RecallTimedOut; + else if (strstr(token, "recall")) + indct = CCBS_IND_Recall; + else if (strstr(token, "irgt")) + indct = CCBS_IND_IrgtResult; + } + + if ((token = strtok(NULL, ",()")) != NULL) + { + strlower(token); + TRACE_EVENT_P1("token: %s", token); + if (strstr(token, "notpresent")) + status = CCBS_STAT_NotPresent; + else if (strstr(token, "notprov")) + status = CCBS_STAT_NotProvisioned; + else if (strstr(token, "prov")) + status = CCBS_STAT_Provisioned; + else if (strstr(token, "active")) + status = CCBS_STAT_Active; + } + + setting.idx = 0; + if ((token = strtok(NULL, ",()")) != NULL) + { + TRACE_EVENT_P1("token: %s", token); + setting.idx = atoi(token); + } + + if (setting.idx != 0) + { + pSetting = &setting; + strcpy(setting.number, "01317180538"); + setting.type.ton = TON_National; + setting.type.npi = NPI_IsdnTelephony; + setting.subaddr[0] = '\0'; + setting.satype.tos = TOS_NotPresent; + setting.satype.oe = OE_NotPresent; + setting.class_type = CLASS_Vce; + setting.alrtPtn = ALPT_Level_0; + + if ((token = strtok(NULL, ",()")) != NULL) + { + TRACE_EVENT_P1("token: %s", token); + strncpy(setting.number, token, sizeof(setting.number)-1); + setting.number[sizeof(setting.number)-1] = '\0'; + } + + if ((token = strtok(NULL, ",()")) != NULL) + { + TRACE_EVENT_P1("token: %s", token); + setting.type.ton = TON_International; + } + } + + TRACE_EVENT_P3("rAT_PercentCCBS(%d, %d, %p)", indct, status, pSetting); + if (pSetting != NULL) + { + TRACE_EVENT_P3("idx = %d: number = %s: ton = %d", + setting.idx, setting.number, setting.type.ton); + } + rAT_PercentCCBS(indct, status, pSetting); + } + else + { + TRACE_EVENT("Unrecognised token"); + } +#endif + } + else + { + TRACE_EVENT("No token"); + } +} +/* Marcus: CCBS testing: 20/11/2002: End */ +#endif /* defined MFW & defined TI_PS_FF_AT_P_CMD_MMITEST */ + +/* SPR#1985 - SH - Added this function */ + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_tty_enable | ++--------------------------------------------------------------------+ + + + PURPOSE : Receipt of unsolicited TTY information + +*/ + +void rAT_PercentCTYI(T_ACI_CTTY_NEG neg, T_ACI_CTTY_TRX trx) +{ + T_MFW_CM_CTYI res; + + TRACE_FUNCTION("rAT_PercentCTYI()"); +#ifdef MMI_LINT_WARNING_REMOVAL /*a0393213 lint warnings removal*/ + currCmd = AT_CMD_NONE; +#endif + switch(neg) + { + case CTTY_NEG_None: + res.neg = CTYI_NONE; + break; + case CTTY_NEG_Request: + res.neg = CTYI_REQUEST; + break; + case CTTY_NEG_Reject: + res.neg = CTYI_REJECT; + break; + case CTTY_NEG_Grant: + res.neg = CTYI_GRANT; + break; + } + + cm_signal(E_CM_CTYI, &res); + + return; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_tty_enable | ++--------------------------------------------------------------------+ + + + PURPOSE : Request ACI to switch TTY on or off + +*/ + +void cm_tty_enable(UBYTE enable) +{ + /*a0393213 compiler warnings removal -- removed ret*/ + +/* Mar 27, 2006 REF:ER OMAPS00071798 */ + #ifdef NEPTUNE_BOARD + U8 audioMode = AUDIO_MODE_TEXT; + #endif + + TRACE_FUNCTION("cm_tty_enable()"); + + /* SPR#1985 - SH - Now use proper ACI functions. */ + + /* sAT_PercentCTTY() is changed bec the audio mode info is needed in lower layer, + for now just use default value when calling the function, if we want to have + the same functionality in BMI/MFW as in ATI, BMI/MFW needs to be updated */ +#ifdef NEPTUNE_BOARD + if (flash_read() >= EFFS_OK) + { + audioMode = FFS_flashData.tty_audio_mode; + } + +#endif + +/* Mar 27, 2006 REF:ER OMAPS00071798 */ +#ifdef NEPTUNE_BOARD +#ifdef CTTY_AUDIO_MODE + if (enable) + sAT_PercentCTTY(CMD_SRC_LCL, CTTY_MOD_Enable, CTTY_REQ_On, audioMode); + else + sAT_PercentCTTY(CMD_SRC_LCL, CTTY_MOD_Enable, CTTY_REQ_Off, audioMode); +#else + if (enable) + sAT_PercentCTTY(CMD_SRC_LCL, CTTY_MOD_Enable, CTTY_REQ_On ); + else + sAT_PercentCTTY(CMD_SRC_LCL, CTTY_MOD_Enable, CTTY_REQ_Off ); +#endif + +#else + if (enable) + sAT_PercentCTTY(CMD_SRC_LCL, CTTY_MOD_Enable, CTTY_REQ_On ); + else + sAT_PercentCTTY(CMD_SRC_LCL, CTTY_MOD_Enable, CTTY_REQ_Off ); +#endif + + + /* SPR#1985 - SH - Check that TTY status has changed and inform MMI */ + + cm_tty_query(); + + return; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_CM | +| STATE : code ROUTINE: cm_tty_query | ++--------------------------------------------------------------------+ + + + PURPOSE : Query status of TTY, inform MMI. */ + /*SPR#1985 - SH - Added this function */ + +void cm_tty_query(void) +{ + T_MFW_CM_CTYI res; +// T_ACI_RETURN ret; // RAVI + T_ACI_CTTY_MOD mode; + T_ACI_CTTY_REQ req; + T_ACI_CTTY_STAT stat; + T_ACI_CTTY_TRX trx; + +/* Mar 27, 2006 REF:ER OMAPS00071798 */ +#ifdef NEPTUNE_BOARD + U8 audio_mode; +#endif + + TRACE_FUNCTION("cm_tty_query()"); + +/* Mar 27, 2006 REF:ER OMAPS00071798 */ +#ifdef NEPTUNE_BOARD +#ifdef CTTY_AUDIO_MODE + qAT_PercentCTTY(CMD_SRC_LCL, &mode, &req, &stat, &trx, &audio_mode); +#else + qAT_PercentCTTY(CMD_SRC_LCL, &mode, &req, &stat, &trx); +#endif +#else + qAT_PercentCTTY(CMD_SRC_LCL, &mode, &req, &stat, &trx); +#endif + + res.neg = CTYI_REJECT; + + if (req==CTTY_REQ_On) + { + if (req) + res.neg = CTYI_GRANT; + } + + cm_signal(E_CM_CTYI, &res); + + return; +} + +// Feb 03, 2005 REF: CRR 25960 x0012850 +// Description: Call Hold: While one call in Active and other in Held by swapping either of phone is not audible + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework MODULE: MFW_CM | +| STATE : code ROUTINE: cm_setSpeechMode | ++--------------------------------------------------------------------+ + + + PURPOSE : MFW function to call psaCC_setSpeechMode() to attach user connection. + +*/ +void cm_setSpeechMode(void) +{ + TRACE_FUNCTION("cm_setSpeechMode()"); + psaCC_setSpeechMode(); + return; +} + + +// Sep 12, 2005 REF: MMI-SMR-34085 x0021334 +// Description: RE: Add +CDIP command - MMI Additions +// Solution: Dummy implementation of function "rAT_PlusCDIP()" is done to enable successful compilation. + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework MODULE: MFW_CM | +| STATE : code ROUTINE : rAT_PlusCDIP | ++--------------------------------------------------------------------+ + + PURPOSE : Stub implementation +*/ + +GLOBAL void rAT_PlusCDIP( CHAR * number, + T_ACI_TOA * type, + CHAR * subaddr, + T_ACI_TOS * satype) +{ + TRACE_FUNCTION ("rAT_PlusCDIP()"); +} + + +/*June 15, 2006 DR:OMAPS00079492 x0043642 */ +/******************************************************************************* + + $Function: set_cmdHold + + $Description: Sets the value of the static variable cmd_hold. + + $Returns: void + + $Arguments: command +*******************************************************************************/ +void set_cmdHold(int command) +{ + TRACE_FUNCTION("set_cmdHold()"); + TRACE_EVENT_P1("Old cmd_hold= %d", cmd_hold); + cmd_hold = command; + TRACE_EVENT_P1("New cmd_hold= %d", cmd_hold); +} + + + + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework MODULE: MFW_CM | +| STATE : code ROUTINE : mfw_get_ALS_type | ++--------------------------------------------------------------------+ + + PURPOSE : this function returns the type of call (voice call or data call etc...) +*/ +//x0pleela 25 May, 2006 DR: OMAPS00070657 +#ifdef FF_CPHS +T_MFW mfw_get_ALS_type() +{ + return in_call.type; +} +#endif + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework MODULE: MFW_CM | +| STATE : code ROUTINE : mfw_set_OtherSrc_Value | ++--------------------------------------------------------------------+ + + PURPOSE : this function sets the value of uOtherSrc to either TRUE or FALSE +*/ +//x0pleela 03 Nov, 2006 DR: OMAPS00101158 +GLOBAL void mfw_set_OtherSrc_Value(UBYTE otherSrc) +{ + TRACE_FUNCTION("mfw_set_OtherSrc_Value"); + uOtherSrc = otherSrc; +} +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework MODULE: MFW_CM | +| STATE : code ROUTINE : mfw_get_OtherSrc_Value | ++--------------------------------------------------------------------+ + + PURPOSE : this function is to get the value of uOtherSrc +*/ +//x0pleela 03 Nov, 2006 DR: OMAPS00101158 +GLOBAL UBYTE mfw_get_OtherSrc_Value(void) +{ + TRACE_FUNCTION("mfw_get_OtherSrc_Value"); + return uOtherSrc; +} +