FreeCalypso > hg > fc-magnetite
view src/ui3/mfw/mfw_cphs.c @ 639:026c98f757a6
tpudrv12.h & targets/gtm900.h: our current support is for MGC2GSMT version only
As it turns out, there exist two different Huawei-made hw platforms both
bearing the marketing name GTM900-B: one is MG01GSMT, the other is MGC2GSMT.
The two are NOT fw-compatible: aside from flash chip differences which
should be handled by autodetection, the two hw platforms are already known
to have different RFFEs with different control signals, and there may be
other differences not yet known. Our current gtm900 build target is for
MGC2GSMT only; we do not yet have a specimen of MG01GSMT on hand, hence
no support for that version will be possible until and unless someone
provides one.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Thu, 30 Jan 2020 18:19:01 +0000 |
parents | d7a40e34fee0 |
children |
line wrap: on
line source
/* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) $Workfile:: mfw_cphs.c $| | $Author:: VO $Revision:: 1 $| | CREATED: 14.7.00 $Modtime:: $| | STATE : code | +--------------------------------------------------------------------+ MODULE : MFW_CPHS PURPOSE : This modul contains CPHS management functions. $History:: mfw_cphs.c $ June 27,2007 OMAPS00134788 x0066814(Geetha) Description: EXT1 record not appende to CHPHS Voice Mail Number (6F17) though referenced Solution: Added a function to read the EXT1 records for mailbox number. Added a condition in cphs_read_mbn() to check whether EXT1 is present. Nov 27, 2006 OMAPS00098359 a0393213(R.Prabakar) Description: CPHS 4.2 : Call Divert doesn't work properly for Line 2 Oct 30 2006, OMAPS00098881 x0039928(sumanth) Removal of power variant May 30, 2006 REF:OMAPS00079650 a0393213 (R.Prabakar) Description : CPHS Call Forwarding feature implementation May 30, 2006 DR: OMAPS00070657 x0pleela Description: CPHS feature on Locosto-Lite Solution: For ALS feature, a) Added the definition for the new function "mfw_cphs_get_als_info()" May 18, 2006 DR: OMAPS00070657 x0pleela Description: CPHS feature on Locosto-Lite Solution: For VMWI feature, a) A new function "sendCPWIEvt" is defined to set the voice mail indication if there are any voice mails Jan 12, 2006 OMAPS00062632 x0018858 Description: The differnace in the type of the data passed to the function cphs_read_information() is causing an incorrect value being received as the output. Solution: The errcode being passed to the function has been modified to USHORT Mar 30, 2005 REF: CRR 29986 xpradipg Description: Optimisation 1: Removal of unused variables and dynamically allocate/ deallocate mbndata Solution: Static allocation of mbnData is replaced with dynamic allocation and deallocation Aug 16, 2004 REF: CRR 24323 Deepa M.D Bug:Clenup of sprintf used for tracing Fix:Replace the char buf[]; sprintf (buf, "...", ...); TRACE_EVENT (buf); statements by TRACE_EVENT_PX */ #define ENTITY_MFW #include <string.h> #include <stdio.h> #include <stdlib.h> #include <limits.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_sim.h" #include "mfw_nm.h" #include "mfw_simi.h" #include "mfw_phb.h" #include "mfw_phbi.h" #include "mfw_cphs.h" #include "mfw_cphsi.h" #include "mfw_win.h" #include "mfw_cm.h" #include "mfw_ss.h" #include "mfw_ffs.h" #include "ksd.h" #include "psa.h" #ifdef SIM_TOOLKIT #include "mfw_sat.h" #endif #if defined (FAX_AND_DATA) #include "aci_fd.h" #endif #include "cmh.h" #include "phb.h" #include "cmh_phb.h" #include "psa_sim.h" #ifndef PCM_2_FFS #include "pcm.h" #include "mfw_ffs.h" #endif //x0pleela 11 june, 2006 DR: OMAPS00079692 //Including this header to get the ACI's VC Status and update MFW VC staus variable #ifdef FF_CPHS #include "Cphs.h" #endif EXTERN MfwHdr * current_mfw_elem; static int cphsCommand (U32 cmd, void *h); /* handle win commands */ /* event parameter define */ static T_MFW_CPHS_OP_NAME opName; static T_MFW_CPHS_VC_NUM mbNum; static T_MFW_CPHS_VC_STAT mbStatus; static T_MFW_CPHS_DV_STAT dvStatus; static T_MFW_CPHS_ALS_STATUS alsStatus; static T_MFW_CPHS_CSP csProfile; static T_MFW_CPHS_INFONUM_LIST numList; static T_MFW_CPHS_INFONUM_ENTRY infoEntry; #ifdef FF_CPHS_REL4 static T_MFW_CPHS_MSP_INFO mspinfo; T_MFW_CPHS_REL4_MWIS mwis_stat[4]; #endif // Mar 30, 2005 REF: CRR 29986 xpradipg // the optimisation is placed under a flag, a pointer variable is defined // instead of the static array, which is allocated and deallocated #ifdef FF_MMI_OPTIM //x0pleela 14 June, 2006 DR: OMAPS00080549 //changed the size of the Mail box number to avoid SIM write operation to overwrite other memory locations #ifdef FF_CPHS #if defined ( TI_PS_FFS_PHB) || defined(PHONEBOOK_EXTENSION) #define MAX_MAIL_BOX_NUMBER 120 #else//TI_PS_FFS_PHB OR PHONEBOOK_EXTENSION #define MAX_MAIL_BOX_NUMBER 120 #endif//TI_PS_FFS_PHB OR PHONEBOOK_EXTENSION #else //FF_CPHS #define MAX_MAIL_BOX_NUMBER 120 #endif //FF_CPHS UBYTE *mbnData; #else //FF_MMI_OPTIM //x0pleela 14 June, 2006 DR: OMAPS00080549 #ifdef FF_CPHS #if defined ( TI_PS_FFS_PHB) || defined(PHONEBOOK_EXTENSION) static UBYTE mbnData[120]; // it should be allocated dynamically. #else//TI_PS_FFS_PHB OR PHONEBOOK_EXTENSION static UBYTE mbnData[120]; // it should be allocated dynamically. #endif//TI_PS_FFS_PHB OR PHONEBOOK_EXTENSION #else //FF_CPHS static UBYTE mbnData[120]; // it should be allocated dynamically. #endif //FF_CPHS #endif //FF_MMI_OPTIM /* PATCH VO 22.01.01 */ static UBYTE mbsData[MFW_CPHS_MBS_SIZE]; // it should be allocated dynamically. static UBYTE dvData[MFW_CPHS_CFF_SIZE]; // it should be allocated dynamically. /* PATCH VO 22.01.01 end */ static T_MFW_CPHS_READ_SIM_ENTRY read_sim_entry;//MC /* variable define */ static T_MFW_CPHS_STATUS cphsStatus; static UBYTE cphsPhase; static UBYTE cphsServTab[CPHS_SERVICE_TABLE]; static UBYTE maxRec; /* PATCH JPS 16.01.01: store mailbox number entry */ static T_MFW_CPHS_ENTRY MbnEntry; /* PATCH JPS 16.01.01 END */ static T_MFW_CPHS_ENTRY *vcEntry; static UBYTE simStatus; static UBYTE alsData; static UBYTE idxLevel; static UBYTE startIdx; static UBYTE cphsUpdate = FALSE; static UINT16 cphsPrevRead = 0; /*June 27,2007 OMAPS00134788 x0066814(Geetha)*/ static UBYTE curr_recNr; static void cphs_read_ext1(SHORT table_id); //Added by Muthu Raja For PCM Reolacement #ifdef PCM_2_FFS #define PSPDF_MBN_ID "/PCM/MBN" /* Mailbox Numbers */ #endif static UBYTE ubCphsMbExtRecNo = 0; static SHORT sFreeRec = 0; static UBYTE ubCurrExtRcWrite = 0; static UBYTE ubFlushRecords = 0; static UBYTE ubExtRecData[200]; static UBYTE flush_data[13]; /* FreeCalypso change: remove unbounded FFS filler */ #if 0 void FFS_log_message(char *LogMsg,...); #define TRACE_FUNCTION FFS_log_message #define TRACE_FUNCTION_P1 FFS_log_message #define TRACE_EVENT FFS_log_message #define TRACE_EVENT_P1 FFS_log_message #define TRACE_EVENT_P2 FFS_log_message #define TRACE_EVENT_P3 FFS_log_message #define TRACE_EVENT_P4 FFS_log_message void FFS_log_message(char *LogMsg,...) { fd_t fd= -1; char log_ffs_buf[256]; va_list varpars; va_start (varpars, LogMsg); vsprintf(log_ffs_buf,LogMsg,varpars); va_end (varpars); fd = ffs_open((const char*)"/ffslog", FFS_O_APPEND | FFS_O_WRONLY ); if(fd < 0) fd=ffs_open((const char*)"/ffslog", FFS_O_CREATE |FFS_O_WRONLY ); if(fd > 0) { strcat(log_ffs_buf, "\n"); ffs_write(fd, log_ffs_buf, strlen(log_ffs_buf)); ffs_close(fd); } } #endif /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_init | +--------------------------------------------------------------------+ PURPOSE : initialize for CPHS management */ void cphs_init(void) { TRACE_FUNCTION("cphs_init()"); cphsStatus = CPHS_NotPresent; simStatus = MFW_SIMOP_UNKNOWN; mfwCommand[MfwTypCphs] = (MfwCb) cphsCommand; } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_exit | +--------------------------------------------------------------------+ PURPOSE : */ void cphs_exit(void) { TRACE_FUNCTION ("cphs_exit()"); } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_create | +--------------------------------------------------------------------+ PURPOSE : create event for CPHS management */ MfwHnd cphs_create (MfwHnd hWin, MfwEvt event, MfwCb cbfunc) { MfwHdr *hdr; T_MFW_CPHS *cphs_para; MfwHdr *insert_status=0; TRACE_FUNCTION("cphs_create()"); hdr = (MfwHdr *) mfwAlloc(sizeof(MfwHdr)); cphs_para = (T_MFW_CPHS *) mfwAlloc(sizeof(T_MFW_CPHS)); if (!hdr || !cphs_para) { TRACE_ERROR("ERROR: cphs_create() Mem Alloc Failed."); if(hdr) mfwFree((U8*)hdr,sizeof(MfwHdr)); if(cphs_para) mfwFree((U8*)cphs_para,sizeof(T_MFW_CPHS)); return FALSE; } cphs_para->emask = event; cphs_para->handler = cbfunc; hdr->data = cphs_para; /* store parameter in node */ hdr->type = MfwTypCphs; /* type of event handler */ insert_status= mfwInsert((MfwHdr *) hWin,hdr); if(!insert_status) { TRACE_ERROR("ERROR: cphs_create() Failed to Install Handler. "); mfwFree((U8*)hdr,sizeof(MfwHdr)); mfwFree((U8*)cphs_para,sizeof(T_MFW_CPHS)); return 0; } return insert_status; } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_delete | +--------------------------------------------------------------------+ PURPOSE : delete a event for CPHS management */ MfwRes cphs_delete (MfwHnd h) { TRACE_FUNCTION("cphs_delete()"); if (!h || !((MfwHdr *) h)->data) return MfwResIllHnd; if (!mfwRemove((MfwHdr *) h)) return MfwResIllHnd; mfwFree(((MfwHdr *) h)->data,sizeof(T_MFW_CPHS)); mfwFree(h,sizeof(MfwHdr)); return MfwResOk; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_sign_exec | +--------------------------------------------------------------------+ PURPOSE : dispatch CPHS management signal */ static int cphs_sign_exec (MfwHdr *cur_elem, MfwEvt event, T_MFW_CPHS_PARA * para) { TRACE_FUNCTION("cphs_sign_exec()"); while (cur_elem) { if (cur_elem->type == MfwTypCphs) { T_MFW_CPHS *cphs_data; cphs_data = (T_MFW_CPHS *) cur_elem->data; if (cphs_data->emask & event) { cphs_data->event = event; TRACE_EVENT_P1("cphs_sign_exec():event=%d",event); switch (event) { case E_CPHS_IND: memcpy(&cphs_data->para.stat, para, sizeof(T_MFW_CPHS_STATUS)); break; case E_CPHS_OP_NAME: memcpy(&cphs_data->para.oper_name, para, sizeof(T_MFW_CPHS_OP_NAME)); break; case E_CPHS_GET_VC_NUM: memcpy(&cphs_data->para.vc_entry, para, sizeof(T_MFW_CPHS_VC_NUM)); break; case E_CPHS_SET_VC_NUM: memcpy(&cphs_data->para.result, para, sizeof(UBYTE)); break; case E_CPHS_GET_VC_STAT: memcpy(&cphs_data->para.vc_status, para, sizeof(T_MFW_CPHS_VC_STAT)); break; case E_CPHS_SET_VC_STAT: memcpy(&cphs_data->para.result, para, sizeof(UBYTE)); break; case E_CPHS_GET_DV_STAT: memcpy(&cphs_data->para.dv_status, para, sizeof(T_MFW_CPHS_DV_STAT)); break; case E_CPHS_SET_DV_STAT: memcpy(&cphs_data->para.result, para, sizeof(UBYTE)); break; case E_CPHS_GET_ALS_STATUS: memcpy(&cphs_data->para.als_status, para, sizeof(T_MFW_CPHS_ALS_STATUS)); break; case E_CPHS_SET_LINE: memcpy(&cphs_data->para.result, para, sizeof(UBYTE)); break; case E_CPHS_GET_CSP: memcpy(&cphs_data->para.csp, para, sizeof(T_MFW_CPHS_CSP)); break; case E_CPHS_GET_INFO_LIST: memcpy(&cphs_data->para.num_list, para, sizeof(T_MFW_CPHS_INFONUM_LIST)); break; case E_CPHS_GET_INFO_NUM: memcpy(&cphs_data->para.info_entry, para, sizeof(T_MFW_CPHS_INFONUM_ENTRY)); break; case E_CPHS_GET_SIM_FIELD://MC added for generic read function memcpy(&cphs_data->para.read_sim_entry, para, sizeof(T_MFW_CPHS_READ_SIM_ENTRY)); break; case E_CPHS_SET_SIM_FIELD://MC added for generic read function memcpy(&cphs_data->para.read_sim_entry, para, sizeof(T_MFW_CPHS_READ_SIM_ENTRY)); break; } if (cphs_data->handler) { // store current mfw elem current_mfw_elem = cur_elem; if ((*(cphs_data->handler)) (cphs_data->event, (void *) &cphs_data->para)) return TRUE; } } } cur_elem = cur_elem->next; } return FALSE; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_signal | +--------------------------------------------------------------------+ PURPOSE : Send a signal */ static void cphs_signal (MfwEvt event, void *para) { /*MC, SPR 1389, we have to enable the display whenever we send an event up to the MMI*/ UBYTE temp=0; #ifndef FF_POWER_MANAGEMENT temp = dspl_Enable(0); #else /*OMAPS00098881 (removing power variant) a0393213(Prabakar) display is enabled only when lcd refresh is needed*/ if(FFS_flashData.refresh == 1) temp = dspl_Enable(0); #endif TRACE_FUNCTION("cphs_signal()"); if (mfwSignallingMethod EQ 0) { if (mfwFocus) if (cphs_sign_exec(mfwFocus,event,para)) { #ifndef FF_POWER_MANAGEMENT dspl_Enable(temp);/*MC, SPR 1389*/ #else /*OMAPS00098881 (removing power variant) a0393213(Prabakar) display is enabled only when lcd refresh is needed*/ if(FFS_flashData.refresh == 1) dspl_Enable(temp);/*MC, SPR 1389*/ #endif return; } if (mfwRoot) cphs_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 (cphs_sign_exec (h, event, para)) { #ifndef FF_POWER_MANAGEMENT dspl_Enable(temp);/*MC, SPR 1389*/ #else /*OMAPS00098881 (removing power variant) a0393213(Prabakar) display is enabled only when lcd refresh is needed*/ if(FFS_flashData.refresh == 1) dspl_Enable(temp);/*MC, SPR 1389*/ #endif return; } /* * All windows tried inclusive root */ if (h == mfwRoot) { #ifndef FF_POWER_MANAGEMENT dspl_Enable(temp);/*MC, SPR 1389*/ #else /*OMAPS00098881 (removing power variant) a0393213(Prabakar) display is enabled only when lcd refresh is needed*/ if(FFS_flashData.refresh == 1) dspl_Enable(temp);/*MC, SPR 1389*/ #endif return; } /* * get parent window */ h = mfwParent(mfwParent(h)); if(h) h = ((MfwWin * )(h->data))->elems; } cphs_sign_exec(mfwRoot,event,para); } // Power Management #ifndef FF_POWER_MANAGEMENT dspl_Enable(temp);/*MC, SPR 1389*/ #else /*OMAPS00098881 (removing power variant) a0393213(Prabakar) display is enabled only when lcd refresh is needed*/ if(FFS_flashData.refresh == 1) dspl_Enable(temp);/*MC, SPR 1389*/ #endif } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: sendCPWIEvt | +--------------------------------------------------------------------+ PURPOSE :this function sends the E_CPHS_GET_VC_STAT event if there is any voice mail MMI doesn't read from the SIM, but will set the vc Status based on the input from ACI */ //18 May, 2006 DR: OMAPS00070657 x0pleela #ifdef FF_CPHS void sendCPWIEvt( UBYTE flag_set, USHORT line ) { T_MFW_CPHS_VC_STAT vc_stat; TRACE_FUNCTION("sendCPWIEvt()"); //11/06/2006 vc_stat.line1 = MFW_CFLAG_NotPresent; vc_stat.line2 = MFW_CFLAG_NotPresent; vc_stat.data = MFW_CFLAG_NotPresent; vc_stat.fax = MFW_CFLAG_NotPresent; switch( line ) { case CPHS_LINE1: if( flag_set ) vc_stat.line1 = MFW_CFLAG_SET; else vc_stat.line1 = MFW_CFLAG_NOTSet; break; case CPHS_LINE2: if( flag_set ) vc_stat.line2 = MFW_CFLAG_SET; else vc_stat.line2 = MFW_CFLAG_NOTSet; break; case CPHS_LINE_DATA: if( flag_set ) vc_stat.data = MFW_CFLAG_SET; else vc_stat.data = MFW_CFLAG_NOTSet; break; case CPHS_LINE_FAX: if( flag_set ) vc_stat.fax = MFW_CFLAG_SET; else vc_stat.fax = MFW_CFLAG_NOTSet; break; default: vc_stat.line1 = MFW_CFLAG_NotPresent; vc_stat.line2 = MFW_CFLAG_NotPresent; vc_stat.data = MFW_CFLAG_NotPresent; vc_stat.fax = MFW_CFLAG_NotPresent; break; } cphs_signal(E_CPHS_GET_VC_STAT,(void*)&vc_stat); } #endif /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: sendCFISEvt | +--------------------------------------------------------------------+ PURPOSE :this function is used to signal CFIS event */ #ifdef FF_CPHS_REL4 void sendCPHSSignal( UBYTE event, void* para) { TRACE_FUNCTION("sendCPHSSignal()"); cphs_signal(event,para); } #endif /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_support_check | +--------------------------------------------------------------------+ PURPOSE : Check whether CPHS is supported. */ void cphs_support_check (void) { TRACE_FUNCTION ("cphs_support_check()"); /* Read CPHS information filed (6F16 - 3 bytes) from SIM card */ if (!cphs_read_sim_dat(SIM_CPHS_CINF, NOT_PRESENT_8BIT, MFW_CPHS_INFO_SIZE)) { /* Read failed */ /*MC-CONQUEST5999->6007, 20/05/2002, set status to ERR rather than NotPresent*/ cphsStatus = CPHS_ERR; TRACE_EVENT("CPHS, error reading support indication"); cphs_signal(E_CPHS_IND, &cphsStatus); } } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_config | +--------------------------------------------------------------------+ PURPOSE : Request the Configuration of CPHS fields */ T_MFW cphs_config (T_MFW_CPHS_INFO *cphs_info) { TRACE_FUNCTION ("cphs_config()"); if (cphs_info NEQ NULL /* AND cphsStatus EQ MFW_CPHS_OK */ ) { cphs_info->phase = cphsPhase; cphs_info->csp = cphs_ssc(MFW_CPHS_CSP, cphsServTab); cphs_info->mbNum = cphs_ssc(MFW_CPHS_MB_NUMBER, cphsServTab); if (cphsPhase EQ 1) /* phase 1 only */ cphs_info->sst = cphs_ssc(MFW_CPHS_SST, cphsServTab); else /* not support */ cphs_info->sst = NO_ALLOCATED; if (cphsPhase EQ 2) /* phase 2 only */ { cphs_info->opNS = cphs_ssc(MFW_CHPS_NAME_SHORT, cphsServTab); cphs_info->iNum = cphs_ssc(MFW_CHPS_INFO_NUMBERS, cphsServTab); } else /* not support */ { cphs_info->opNS = NO_ALLOCATED; cphs_info->iNum = NO_ALLOCATED; } } return cphsStatus; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_operator_name | +--------------------------------------------------------------------+ PURPOSE : Request the network operator name */ T_MFW cphs_operator_name (void) { TRACE_FUNCTION ("cphs_operator_name()"); /* Check CPHS support status */ if (cphsStatus EQ CPHS_NotPresent) return cphsStatus; /* Read operator name sring */ if (!cphs_read_sim_dat(SIM_CPHS_ONSTR, NOT_PRESENT_8BIT, MFW_CPHS_ONS_SIZE)) { /* Read operator name sring failed */ opName.longName.len = 0; /* Read operator name shortform */ if ((cphsPhase NEQ 2) OR (cphs_ssc(MFW_CHPS_NAME_SHORT, cphsServTab) NEQ ALLOCATED_AND_ACTIVATED) OR !cphs_read_sim_dat(SIM_CPHS_ONSHF, NOT_PRESENT_8BIT, MFW_CPHS_ONSF_SIZE) ) { /* Read operator name shortform failed. Send event with empty info to MMI */ opName.shortName.len = 0; cphs_signal(E_CPHS_OP_NAME, &opName); } } return cphsStatus; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_get_mailbox | +--------------------------------------------------------------------+ PURPOSE : Request the Mailbox Numbers */ void cphs_get_mailbox (void) { TRACE_FUNCTION ("cphs_get_mailbox()"); mbNum.count = 0; /* Check CPHS support status. When CPHS is not support, read mailbox numbers from EEPROM */ if (cphsStatus EQ CPHS_NotPresent) { cphs_read_eeprom_mailbox(); return; } /* Check CPHS service table. When CPHS is not support, read mailbox numbers from EEPROM */ if (cphs_ssc(MFW_CPHS_MB_NUMBER, cphsServTab) NEQ ALLOCATED_AND_ACTIVATED) { cphs_read_eeprom_mailbox(); return; } /* Read mailbox numbers from SIM. When this reading failed, read mailbox numbers from EEPROM */ if (!cphs_read_sim_rcd(SIM_CPHS_MBXN, 1, 0)) /* read the first record */ cphs_read_eeprom_mailbox(); } static UBYTE cphs_write_sim_voicemail_rcd(void) { BOOL bSavePossible = FALSE; UBYTE result = MFW_SIMOP_WRITE_OK; TRACE_FUNCTION("cphs_write_sim_voicemail_rcd"); /* allocate mbnData (sizeof(dataLen)) */ // Mar 30, 2005 REF: CRR 29986 xpradipg // the dynamic allocation is done here, if the write fails it is deallocated // else if success it is deallocated in the callback #ifdef FF_MMI_OPTIM mbnData = (UBYTE*)mfwAlloc(200); if(mbnData != NULL) { #endif ubCphsMbExtRecNo = 0; sFreeRec = 0; ubCurrExtRcWrite = 0; ubFlushRecords = 0; bSavePossible = cphs_build_mbn_data(mbnData, vcEntry->datalen); /**************************************************************************************/ /**************************************************************************************/ /* Check if enough EXT1 Records are available for storing the current number; If not, show Write Error */ if ( bSavePossible == FALSE ) { result = MFW_SIMOP_WRITE_ERR; TRACE_FUNCTION("cphs_write_sim_voicemail_rcd: notenuf EXT1recs"); cphs_signal(E_CPHS_SET_VC_NUM, &result); // Mar 30, 2005 REF: CRR 29986 xpradipg // mbnData is deallocated, on failure of write operation #ifdef FF_MMI_OPTIM if(mbnData) mfwFree(mbnData,200); #endif return 0; } /**************************************************************************************/ /**************************************************************************************/ if (!cphs_write_sim_rcd(SIM_CPHS_MBXN, vcEntry->index, mbnData, vcEntry->datalen)) { cphs_write_eeprom_mailbox(vcEntry); } #ifdef FF_MMI_OPTIM } #endif return 1; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_set_mailbox | +--------------------------------------------------------------------+ PURPOSE : Save the Mailbox Numbers */ T_MFW cphs_set_mailbox (T_MFW_CPHS_ENTRY *entry) { TRACE_FUNCTION ("cphs_set_mailbox()"); TRACE_EVENT_P1("no: %s", entry->number); if (entry NEQ NULL AND strlen((char *)entry->number) NEQ 0 ) /* PATCH JPS 16.01.01: must copy the data and not only point on it!! */ { memcpy((char *)&MbnEntry, (char *)entry, sizeof(T_MFW_CPHS_ENTRY)); //vcEntry = entry; vcEntry = &MbnEntry; // VO ??? } else return CPHS_ERR; if ((entry->index <= 0) OR (entry->index > 4) ) return CPHS_ERR; /* Check CPHS support status. When CPHS is not support, write mailbox numbers to EEPROM */ if (cphsStatus EQ CPHS_NotPresent) { cphs_write_eeprom_mailbox(entry); //x0pleela 11 June, 2006 DR:OMAPS00079692 //changed from CPHS_OK to MFW_CPHS_OK return MFW_CPHS_OK; } /* Check CPHS service table. When CPHS is not support, write mailbox numbers to EEPROM */ if ( cphs_ssc(MFW_CPHS_MB_NUMBER, cphsServTab) NEQ ALLOCATED_AND_ACTIVATED) { cphs_write_eeprom_mailbox(entry); //x0pleela 11 June, 2006 DR:OMAPS00079692 //changed from CPHS_OK to MFW_CPHS_OK return MFW_CPHS_OK; } /* Read first record to determine the data length, When the reading failed, write mailbox numbers to EEPROM */ // simStatus = MFW_SIMOP_WRITE_OK; if (!cphs_write_sim_voicemail_rcd()) { return CPHS_ERR; } //x0pleela 11 June, 2006 DR:OMAPS00079692 //changed from CPHS_OK to MFW_CPHS_OK return MFW_CPHS_OK; } /* +-------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_get_mailbox_status | +-------------------------------------------------------------------------+ PURPOSE : get the voice message waiting flag */ T_MFW cphs_get_mailbox_status () { TRACE_FUNCTION ("cphs_get_mailbox_status()"); /* Read voice message waiting flag. When this reading failed, send event with "read error" parameter to MMI */ if (!cphs_read_sim_dat(SIM_CPHS_VMW, NOT_PRESENT_8BIT, MFW_CPHS_MBS_SIZE)) { mbStatus.result = MFW_SIMOP_READ_ERR; cphs_signal(E_CPHS_GET_VC_STAT, &mbStatus); } return cphsStatus; } /* +-------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_rel4_get_mailbox_status | +-------------------------------------------------------------------------+ PURPOSE : get the voice message waiting flag */ #ifdef FF_CPHS_REL4 void cphs_rel4_get_mailbox_status() { TRACE_FUNCTION("cphs_rel4_get_mailbox_status"); qAT_PercentMWIS(CMD_SRC_LCL,0xFF);/*mspId is set to FF to get MWIS for all profiles*/ } T_MFW_CPHS_REL4_MWIS* get_mwis_stat(int profile) { return &mwis_stat[profile -1]; } #endif /* +-------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_set_mailbox_status | +-------------------------------------------------------------------------+ PURPOSE : Save the voice message waiting flag */ T_MFW cphs_set_mailbox_status (T_MFW_CFLAG_STATUS line1, T_MFW_CFLAG_STATUS line2, T_MFW_CFLAG_STATUS fax, T_MFW_CFLAG_STATUS data) { UBYTE result; TRACE_FUNCTION ("cphs_set_mailbox_status()"); /* Check CPHS support status. */ if (cphsStatus EQ CPHS_NotPresent) { TRACE_EVENT("cphsStatus is CPHS_NotPresent !"); return cphsStatus; } /* Write status in buffer */ if (line1 EQ MFW_CFLAG_SET OR line1 EQ MFW_CFLAG_NOTSet ) { mbsData[0] &=0xF0; //zero the lower nibble mbsData[0] |= line1&0x0F; /* low Nibble */ } /*else mbsData[0] = 0x0F;*/ if (line2 EQ MFW_CFLAG_SET OR line2 EQ MFW_CFLAG_NOTSet ) { mbsData[0]&=0x0F; mbsData[0] |= (line2 << 4)&0xF0;; /* high Nibble */ } if (fax EQ MFW_CFLAG_SET OR fax EQ MFW_CFLAG_NOTSet ) { mbsData[1] &= 0xF0; //zero the low nibble mbsData[1] |= fax&0x0F; /* low Nibble */ } if (data EQ MFW_CFLAG_SET OR data EQ MFW_CFLAG_NOTSet ) { mbsData[1] &= 0x0F; //zero the high nibble mbsData[1] |= (data << 4)&0xF0; /* high Nibble */ } /* Read voice message waiting flag to determine the size */ simStatus = MFW_SIMOP_WRITE_OK; if (!cphs_read_sim_dat(SIM_CPHS_VMW, NOT_PRESENT_8BIT, MFW_CPHS_MBS_SIZE)) { result = MFW_SIMOP_WRITE_ERR; cphs_signal(E_CPHS_SET_VC_STAT, &result); } /* PATCH VO 22.01.01 end */ return cphsStatus; } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_get_divert_status | +------------------------------------------------------------------------+ PURPOSE : Request the call forwarding flags */ T_MFW cphs_get_divert_status () { TRACE_FUNCTION ("cphs_get_divert_status()"); /* Read call forwarding flags. When this reading failed, send event with "read error" parameter to MMI */ /*a0393213 cphs rel4 - when EF(CFIS) is present call sAT_PercentCFIS to get CFIS*/ #ifdef FF_CPHS_REL4 if(sim_serv_table_check((UBYTE)SRV_No_55) != ALLOCATED_AND_ACTIVATED ) { #endif if (!cphs_read_sim_dat(SIM_CPHS_CFF, NOT_PRESENT_8BIT, MFW_CPHS_CFF_SIZE)) { dvStatus.result = MFW_SIMOP_READ_ERR; cphs_signal(E_CPHS_GET_DV_STAT, &dvStatus); } #ifdef FF_CPHS_REL4 } else { UBYTE mspId=mfw_cphs_get_reg_profile(); TRACE_EVENT_P1("msp id %d", mspId); /*needs clarification regarding third and fourth parameters*/ sAT_PercentCFIS(CMD_SRC_LCL, CFIS_MOD_Read, mspId , mspId, 0, NULL, NULL, 0); } #endif return cphsStatus; } /* +-------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_set_divert_status | +-------------------------------------------------------------------------+ PURPOSE : Save the call forwarding flag */ T_MFW cphs_set_divert_status (T_MFW_CFLAG_STATUS line1, T_MFW_CFLAG_STATUS line2, T_MFW_CFLAG_STATUS fax, T_MFW_CFLAG_STATUS data) { UBYTE result; TRACE_EVENT_P4 ("cphs_set_divert_status() %d %d %d %d",line1,line2,fax,data); /* Write status in buffer */ if (line1 EQ MFW_CFLAG_SET OR line1 EQ MFW_CFLAG_NOTSet ) { dvData[0]&= 0xF0; //zero the lower nibble dvData[0] |= line1&0x0F; /* low Nibble */ } if (line2 EQ MFW_CFLAG_SET OR line2 EQ MFW_CFLAG_NOTSet ) { dvData[0]&= 0x0F; dvData[0] |= (line2 << 4)&0xF0; /* high Nibble */ } if (fax EQ MFW_CFLAG_SET OR fax EQ MFW_CFLAG_NOTSet ) { dvData[1]&= 0xF0; //zero the lower nibble dvData[1] |= fax&0x0F; /* low Nibble */ } if (data EQ MFW_CFLAG_SET OR data EQ MFW_CFLAG_NOTSet ) { dvData[1] &=0x0F; dvData[1] |= (data << 4)&0xF0; /* high Nibble */ } /* Read call forwarding flag to determine the size */ simStatus = MFW_SIMOP_WRITE_OK; if (!cphs_read_sim_dat(SIM_CPHS_CFF, NOT_PRESENT_8BIT, MFW_CPHS_CFF_SIZE)) { TRACE_EVENT("cphs_set_divert_status:cphs_read_sim_dat failed"); result = MFW_SIMOP_WRITE_ERR; cphs_signal(E_CPHS_SET_DV_STAT, &result); } return cphsStatus; } /* +-------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_rel4_set_divert_status | +-------------------------------------------------------------------------+ PURPOSE : Save the call forwarding flag into SIM by calling sAT_PercentCFIS PARAMETERS: voice - call forward status for voice fax - call forward status for fax data - call forward status for data */ #ifdef FF_CPHS_REL4 T_MFW cphs_rel4_set_divert_status(T_MFW_CFLAG_STATUS voice, T_MFW_CFLAG_STATUS fax, T_MFW_CFLAG_STATUS data, char number[PHB_MAX_LEN]) { UBYTE mspId=mfw_cphs_get_reg_profile(); UBYTE cfuStat=0x00; TRACE_FUNCTION("cphs_rel4_set_divert_status"); TRACE_EVENT_P4("voice - %d, fax - %d, data - %d, number - %s", voice, fax, data, number); TRACE_EVENT_P1("msp id %d",mspId); cfuStat= cfuStat | (voice == MFW_CFLAG_SET) | ((fax==MFW_CFLAG_SET)<<1) | ((data==MFW_CFLAG_SET)<<2); /*check third, fourth, sixth, seventh and eight parameters, number convert to 10 digit, TOA - psaSAT_getTonNpi is a local fn in ACI*/ sAT_PercentCFIS( CMD_SRC_LCL, CFIS_MOD_Write, mspId, mspId, cfuStat, number, NULL, 0xFF); return cphsStatus; } #endif /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_get_als_info | +---------------------------------------------------------------------+ PURPOSE : Request the Status of Alternate Line Service information (first read selected ALS line, dann status of this line). When the field does not exist in SIM, read it from EEPROM. */ void cphs_get_als_info (T_MFW_CPHS_ALS_STATUS *info) { TRACE_FUNCTION ("cphs_get_als_info()"); /* read alternate line service from EEPROM */ cphs_read_eeprom_als(info); cphs_signal(E_CPHS_GET_ALS_STATUS, &alsStatus); } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_select_line | +---------------------------------------------------------------------+ PURPOSE : Select the current used line. When the field does not exist in SIM, read it from EEPROM. */ void cphs_select_line (T_MFW_LINE_INDEX line) { UBYTE result; T_ACI_ALS_MOD alsMode=ALS_MOD_NOTPRESENT; TRACE_EVENT_P1 ("cphs_select_line() %d",line); if (line NEQ MFW_SERV_LINE1 AND line NEQ MFW_SERV_LINE2 ) { result = MFW_SIMOP_WRITE_ERR; cphs_signal(E_CPHS_SET_LINE, &result); return; } alsData = (UBYTE) line; /* write alternate line service in EEPROM */ cphs_write_eeprom_als(&result); if (line EQ MFW_SERV_LINE1) alsMode = ALS_MOD_SPEECH; if (line EQ MFW_SERV_LINE2) alsMode = ALS_MOD_AUX_SPEECH; sAT_PercentALS(CMD_SRC_LCL, alsMode); cphs_signal(E_CPHS_SET_LINE, &result); } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_set_als_status | +---------------------------------------------------------------------+ PURPOSE : Change the lock status of the line. When the field does not exist in SIM, read it from EEPROM. */ T_MFW cphs_set_als_status (T_MFW_LINE_STATUS status) { UBYTE result; T_MFW_SIM_PIN_STATUS pinStatus; TRACE_FUNCTION ("cphs_set_als_status()"); /* check PIN 2 requirement */ pinStatus.type = MFW_SIM_PIN2; sim_pin_status(&pinStatus); if (pinStatus.stat NEQ MFW_SIM_NO_PIN) return MFW_SIM_PIN2_REQ; /* check given parameter */ if (status NEQ MFW_LINE_LOCKED AND status NEQ MFW_LINE_UNLOCKED ) { result = MFW_SIMOP_WRITE_ERR; cphs_signal(E_CPHS_SET_ALS_STATUS, &result); return CPHS_ERR; } alsData = (UBYTE) status; /* write lock status in EEPROM */ cphs_write_eeprom_alss(&result); cphs_signal(E_CPHS_SET_LINE, &result); //x0pleela 11 June, 2006 DR:OMAPS00079692 //changed from CPHS_OK to MFW_CPHS_OK return MFW_CPHS_OK; } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_get_csp | +---------------------------------------------------------------------+ PURPOSE : Request the customer service profile */ T_MFW cphs_get_csp () { UBYTE res; TRACE_FUNCTION ("cphs_get_csp()"); /* check CPHS service table */ res = cphs_ssc(MFW_CPHS_CSP, cphsServTab); if ( res NEQ ALLOCATED_AND_ACTIVATED) return res; /* Read customer service profile. When this reading failed, send event with empty parameter array to MMI */ if (!cphs_read_sim_dat(SIM_CPHS_CSP, NOT_PRESENT_8BIT, MFW_CPHS_CSP_SIZE)) { csProfile.result = MFW_SIMOP_READ_ERR; memset(csProfile.csp, 0, sizeof(csProfile.csp)); cphs_signal(E_CPHS_GET_CSP, &csProfile); } return cphsStatus; } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_get_info_num | +---------------------------------------------------------------------+ PURPOSE : Request information numbers directory */ T_MFW cphs_get_info_num (UBYTE level, UBYTE startIndex) { // UBYTE res; // RAVI T_MFW_CPHS_INFO cf_info; TRACE_FUNCTION ("cphs_get_info_num()"); if (level < 1 OR startIndex < 1 ) return CPHS_ERR; cphs_config(&cf_info); /* Read customer service profile to check whether information numbers are supported. */ numList.count = 0; idxLevel = level; startIdx = startIndex; simStatus = MFW_SIMOP_READ_OK; if (!cphs_read_sim_dat(SIM_CPHS_CSP, NOT_PRESENT_8BIT, MFW_CPHS_CSP_SIZE)) { simStatus = MFW_SIMOP_UNKNOWN; TRACE_EVENT("Can't read CSP for info nums"); return CPHS_NotPresent; } return cphsStatus; } /* +----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_select_info_num | +----------------------------------------------------------------------+ PURPOSE : read a information number entry */ T_MFW cphs_select_info_num (UBYTE index) { TRACE_FUNCTION ("cphs_select_info_num()"); /* Read a information number entry. When this reading failed, send event with "read error" parameter to MMI */ simStatus = MFW_SIMOP_READ_OK; startIdx = index; // By now we know if 6F19 or EA01 are present for reading info. num entries from // So lets use this knowledge. if (cphsPrevRead == SIM_CPHS_INFN) { if (!cphs_read_sim_rcd(SIM_CPHS_INFN, 1, 0)) { infoEntry.result = MFW_SIMOP_READ_ERR; cphs_signal(E_CPHS_GET_INFO_NUM, &infoEntry); TRACE_EVENT("Error reading single info num"); } else { cphsPrevRead = SIM_CPHS_INFN; } } else { if (cphsPrevRead == SIM_CPHS_INFN2) { if (!cphs_read_sim_rcd(SIM_CPHS_INFN2, 1, 0)) {TRACE_EVENT("Error reading single info num 2"); infoEntry.result = MFW_SIMOP_READ_ERR; cphs_signal(E_CPHS_GET_INFO_NUM, &infoEntry); } else { cphsPrevRead = SIM_CPHS_INFN2; } } } return cphsStatus; } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_information | +-----------------------------------------------------------------------+ PURPOSE : Read CPHS information */ //x0018858 OMAPS00062632 The errcode type has been modified from SHORT to USHORT. void cphs_read_information(USHORT errCode, UBYTE *data, UBYTE dataLen) { UBYTE *ptr; /* PATCH VO 22.01.01: copy CPHS service table according to the actual length in the SIM card */ UBYTE len; /* PATCH VO 22.01.01 END */ TRACE_FUNCTION ("cphs_read_information()"); ptr = data; /* PATCH VO 22.01.01: copy CPHS service table according to the actual length in the SIM card */ len = dataLen; memset(cphsServTab, 0, sizeof(cphsServTab)); /* PATCH VO 22.01.01 END */ #ifdef FF_2TO1_PS if ( errCode NEQ CAUSE_SIM_NO_ERROR OR #else if ( errCode NEQ SIM_NO_ERROR OR #endif ptr EQ NULL OR dataLen <= 0) /* PATCH VO 22.01.01: not check a certain length */ { cphs_signal(E_CPHS_IND, &cphsStatus); } else { cphsPhase = *ptr; len--; if (len > 0) { ptr++; memcpy (cphsServTab, ptr, MINIMUM(len, CPHS_SERVICE_TABLE)); } /* PATCH VO 22.01.01 END */ //x0pleela 11 June, 2006 DR:OMAPS00079692 //changed from CPHS_OK to MFW_CPHS_OK cphsStatus = MFW_CPHS_OK; TRACE_EVENT("CPHS supported"); cphs_signal(E_CPHS_IND, &cphsStatus); } } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_ons | +-----------------------------------------------------------------------+ PURPOSE : Read operator name short form */ void cphs_read_ons(USHORT errCode, UBYTE *data, UBYTE dataLen) { UBYTE *ptr; TRACE_FUNCTION ("cphs_read_ons()"); ptr = data; #ifdef FF_2TO1_PS if ( errCode NEQ CAUSE_SIM_NO_ERROR OR #else if ( errCode NEQ SIM_NO_ERROR OR #endif ptr EQ NULL OR // dataLen < MFW_CPHS_ONS_SIZE ) dataLen <= 0 ) /* PATCH VO 22.01.01: not check a certain length */ { opName.longName.len = 0; } else { cmhPHB_getMfwTagNt(ptr, (UBYTE)MINIMUM(LONG_NAME, dataLen), opName.longName.data, &opName.longName.len); opName.longName.dcs = MFW_DCS_SIM; /* Read operator name shortform */ if ((cphsPhase NEQ 2) OR (cphs_ssc(MFW_CHPS_NAME_SHORT, cphsServTab) NEQ ALLOCATED_AND_ACTIVATED) OR !cphs_read_sim_dat(SIM_CPHS_ONSHF, NOT_PRESENT_8BIT, MFW_CPHS_ONSF_SIZE) ) { opName.shortName.len = 0; if (opName.longName.len != 0) TRACE_EVENT("Got a long name!!!"); cphs_signal(E_CPHS_OP_NAME, &opName); } } } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_onsf | +-----------------------------------------------------------------------+ PURPOSE : Read operator name short form */ void cphs_read_onsf(USHORT errCode, UBYTE *data, UBYTE dataLen) { UBYTE *ptr; TRACE_FUNCTION ("cphs_read_onsf()"); ptr = data; #ifdef FF_2TO1_PS if ( errCode NEQ CAUSE_SIM_NO_ERROR OR #else if ( errCode NEQ SIM_NO_ERROR OR #endif ptr EQ NULL OR dataLen < MFW_CPHS_ONSF_SIZE ) { opName.shortName.len = 0; } else { cmhPHB_getMfwTagNt(ptr, MFW_CPHS_ONSF_SIZE, opName.shortName.data, &opName.shortName.len); opName.shortName.dcs = MFW_DCS_SIM; TRACE_EVENT("Got a short Name"); } cphs_signal(E_CPHS_OP_NAME, &opName); } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_mbn | +-----------------------------------------------------------------------+ PURPOSE : Read mailbox numbers */ void cphs_read_mbn(SHORT table_id) { UBYTE* pData; /* points to data buffer */ UBYTE alphaLen; UBYTE dataLen; T_ACI_TOA type; TRACE_FUNCTION ("cphs_read_mbn()"); pData = simShrdPrm.atb[table_id].exchData; dataLen = simShrdPrm.atb[table_id].dataLen; /*June 27,2007 OMAPS00134788 x0066814(Geetha)*/ curr_recNr = simShrdPrm.atb[table_id].recNr; TRACE_EVENT_P1("curr_recNr: %d", curr_recNr); TRACE_EVENT_P1("dataLen: %d", dataLen); #ifdef FF_2TO1_PS if ( simShrdPrm.atb[table_id].errCode NEQ CAUSE_SIM_NO_ERROR OR #else if ( simShrdPrm.atb[table_id].errCode NEQ SIM_NO_ERROR OR #endif pData EQ NULL OR dataLen < MFW_CPHS_MIN_MBN_SIZE ) { /*June 27,2007 OMAPS00134788 x0066814(Geetha)*/ if (curr_recNr <= 1) { cphs_read_eeprom_mailbox(); return; } else { cphs_signal(E_CPHS_GET_VC_NUM, &mbNum); } } else /* no read error */ { /*June 27,2007 OMAPS00134788 x0066814(Geetha)*/ if (curr_recNr EQ 1) { maxRec = simShrdPrm.atb[table_id].recMax; } if ( dataLen >= MFW_CPHS_MIN_MBN_SIZE ) { alphaLen = dataLen - MFW_CPHS_MIN_MBN_SIZE; } else { alphaLen = 0; } /* Copy/encode data */ if ( ( *(pData + alphaLen) > 0 ) /* If Length of the contents is > 0 */ && ( *(pData + alphaLen) <= 11 ) ) { /*June 27,2007 OMAPS00134788 x0066814(Geetha)*/ mbNum.entries[mbNum.count].index = curr_recNr; mbNum.entries[mbNum.count].datalen = dataLen; TRACE_EVENT_P1("mbNum.count: %d", mbNum.count); TRACE_EVENT_P1("mbNum.entries[mbNum.count].index: %d", mbNum.entries[mbNum.count].index); cmhPHB_getMfwTagNt(pData, alphaLen, mbNum.entries[mbNum.count].alpha.data, &mbNum.entries[mbNum.count].alpha.len); pData += alphaLen; if ( *(pData) > 1 ) { cmhPHB_getAdrStr ( (CHAR *)mbNum.entries[mbNum.count].number, PHB_MAX_LEN - 1, pData + 2, *pData ); } else { memset ( (void *)mbNum.entries[mbNum.count].number, 0, PHB_MAX_LEN ); } cmhPHB_toaDmrg ( *( pData + 1 ), &type ); mbNum.entries[mbNum.count].ton = phb_cvtTon(type.ton); mbNum.entries[mbNum.count].npi = phb_cvtNpi(type.npi); mbNum.entries[mbNum.count].ext_rec_number = 0; TRACE_EVENT_P1("dataLen: %d", dataLen); TRACE_EVENT_P1("alphaLen: %d", alphaLen); TRACE_EVENT_P2("cphs_read_mbn: idx, ext_rec_number: %d, %d", mbNum.count, mbNum.entries[mbNum.count].ext_rec_number); pData += 12; if ( *pData NEQ 0xFF ) { /* read bearer capability EF */ /* return; */ } /*June 27,2007 OMAPS00134788 x0066814(Geetha)*/ pData += 1; if ( *pData NEQ 0xFF ) { /*Read EXT1 EF */ UBYTE rcd_no; rcd_no= *pData; mbNum.entries[mbNum.count].ext_rec_idx[mbNum.entries[mbNum.count].ext_rec_number] = rcd_no; if(!cphs_read_sim_rcd(SIM_EXT1,rcd_no,UCHAR_MAX)) { /*Append the extension data to mailbox number*/ TRACE_FUNCTION("EXTENSION RECORD PRESENT"); } else { /*EXT1 record is being read. Wait the corr callback.*/ return; } } mbNum.count++; } curr_recNr++; if (curr_recNr > maxRec) { TRACE_EVENT("got CPHS MAilbox nos"); cphs_signal(E_CPHS_GET_VC_NUM, &mbNum); } else { /* Read the next entry */ if (!cphs_read_sim_rcd(SIM_CPHS_MBXN, curr_recNr, UCHAR_MAX)) { cphs_signal(E_CPHS_GET_VC_NUM, &mbNum); } } } } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_ext1 | +-----------------------------------------------------------------------+ PURPOSE : Read EXT1 record for mailbox numbers */ /*June 27,2007 OMAPS00134788 x0066814(Geetha)*/ void cphs_read_ext1(SHORT table_id) { UBYTE* pData; /* points to data buffer */ UBYTE alphaLen; UBYTE dataLen; UBYTE recNr; UBYTE ext_rec_no; T_ACI_TOA type; UBYTE ext1num[PHB_MAX_LEN]; TRACE_FUNCTION ("cphs_read_ext1()"); pData = simShrdPrm.atb[table_id].exchData; dataLen = simShrdPrm.atb[table_id].dataLen; recNr = simShrdPrm.atb[table_id].recNr; if ( *pData EQ 0x02 ) //implies that the EF conatins additional data { /*Extract ext data*/ if(*(pData+1) NEQ 0xFF) { alphaLen=*(pData+1); cmhPHB_getAdrStr ( (CHAR *)ext1num, PHB_MAX_LEN - 1, pData + 2, *(pData+1) ); strncat( (CHAR *)mbNum.entries[mbNum.count].number, (CHAR *)ext1num, strlen((CHAR *)ext1num) ); mbNum.entries[mbNum.count].ext_rec_number++; TRACE_EVENT_P2("cphs_read_ext1: idx, ext_rec_number: %d, %d", mbNum.count, mbNum.entries[mbNum.count].ext_rec_number); if ( *(pData + 12) == 0xFF ) { //return control to mbn curr_recNr++; mbNum.count++; if (curr_recNr > maxRec) { TRACE_EVENT("got CPHS MAilbox nos-2"); cphs_signal(E_CPHS_GET_VC_NUM, &mbNum); } else { if(!cphs_read_sim_rcd(SIM_CPHS_MBXN, curr_recNr, UCHAR_MAX)) { TRACE_FUNCTION("Control Back to mbn-1"); return; } } } else { ext_rec_no = *(pData + 12); mbNum.entries[mbNum.count].ext_rec_idx[mbNum.entries[mbNum.count].ext_rec_number] = ext_rec_no; if(!cphs_read_sim_rcd(SIM_EXT1,ext_rec_no,UCHAR_MAX)) { /*Append the extension data to mailbox number*/ TRACE_FUNCTION( " MORE EXTENSION RECORDS PRESENT -But read Error"); curr_recNr++; mbNum.count++; if(!cphs_read_sim_rcd(SIM_CPHS_MBXN, curr_recNr, UCHAR_MAX)) { TRACE_FUNCTION("Control Back to mbn-2"); return; } } } } } else ; return; } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_rel4_get_mailbox_id | +-----------------------------------------------------------------------+ PURPOSE : Get mailbox identifiers for the registered profile */ #ifdef FF_CPHS_REL4 void cphs_rel4_get_mailbox_id() { UBYTE mspId=mfw_cphs_get_reg_profile(); TRACE_FUNCTION("cphs_rel4_get_mailbox_id"); /*get Mailbox Identifiers for the registered profile*/ qAT_PercentMBI(CMD_SRC_LCL,mspId); } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_rel4_get_mailbox_no | +-----------------------------------------------------------------------+ PURPOSE : Get mailbox number from the given index */ void cphs_rel4_get_mailbox_no(UBYTE index) { TRACE_FUNCTION("cphs_rel4_get_mailbox_no"); /*get mailbox number for the supplied index - the call is asynchronous*/ qAT_PercentMBDN(CMD_SRC_LCL,index); } /******************************************************************************* $Function: is_message_waiting $Description: returns true if any message (in any profile) is waiting *******************************************************************************/ BOOL is_message_waiting(void) { TRACE_FUNCTION("is_message_waiting"); if(mwis_stat[0].mwisStat&0x0F || mwis_stat[1].mwisStat&0x0F || mwis_stat[2].mwisStat&0x0F || mwis_stat[3].mwisStat&0x0F) return TRUE; else return FALSE; } #endif /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_mbs | +-----------------------------------------------------------------------+ PURPOSE : Read voice message waiting flag */ void cphs_read_mbs(USHORT errCode, UBYTE *data, UBYTE dataLen) { UBYTE *ptr; int i; /* PATCH VO 22.01.01 */ TRACE_FUNCTION ("cphs_read_mbs()"); ptr = data; #ifdef FF_2TO1_PS if ( errCode NEQ CAUSE_SIM_NO_ERROR OR #else if ( errCode NEQ SIM_NO_ERROR OR #endif ptr EQ NULL OR dataLen <= 0 ) /* PATCH VO 22.01.01: not check a certain length */ { mbStatus.result = MFW_SIMOP_READ_ERR; } else { memset(&mbStatus, MFW_CFLAG_NotPresent, sizeof(mbStatus)); //x0pleela, 07 June, 2006 DVT: OMAPS00079692 //Copy SIM data into mbsData to initialise mbsData with the SIM data instead of zeros memcpy( mbsData, ptr, dataLen ); mbStatus.result = MFW_SIMOP_READ_OK; for (i=0; i<dataLen; i++) { switch (i) { case 0: mbStatus.line1 = (T_MFW_CFLAG_STATUS)(ptr[i] & 0x0F); /*a0393213 compiler warnings removal - extra parenthesis added*/ mbStatus.line2 = (T_MFW_CFLAG_STATUS)(( ptr[i] >> 4 ) & 0x0F); break; case 1: mbStatus.fax = (T_MFW_CFLAG_STATUS)(ptr[i] & 0x0F); mbStatus.data = (T_MFW_CFLAG_STATUS)(( ptr[i] >> 4 ) & 0x0F); break; default: break; } } /* PATCH VO 22.01.01 END */ } TRACE_EVENT("Reading Mailboxes"); cphs_signal(E_CPHS_GET_VC_STAT, &mbStatus); } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_cff | +-----------------------------------------------------------------------+ PURPOSE : Read call forwarding flag */ void cphs_read_cff(USHORT errCode, UBYTE *data, UBYTE dataLen) { UBYTE *ptr; int i; /* PATCH VO 22.01.01 */ TRACE_FUNCTION ("cphs_read_cff()"); ptr = data; #ifdef FF_2TO1_PS if ( errCode NEQ CAUSE_SIM_NO_ERROR OR #else if ( errCode NEQ SIM_NO_ERROR OR #endif ptr EQ NULL OR dataLen <= 0 ) /* PATCH VO 22.01.01: not check a certain length */ { dvStatus.result = MFW_SIMOP_READ_ERR; } else { memset(&dvStatus, MFW_CFLAG_NotPresent, sizeof(dvStatus)); /* May 30, 2006 REF:OMAPS00079650 a0393213 (R.Prabakar) Description : CPHS Call Forwarding feature implementation Solution : As part of this implementation, dvData is made to be consistent with the data read from SIM*/ memcpy(&dvData, ptr,dataLen); dvStatus.result = MFW_SIMOP_READ_OK; for (i=0; i<dataLen; i++) { switch (i) { case 0: dvStatus.line1 = (T_MFW_CFLAG_STATUS)(ptr[i] & 0x0F); /*a0393213 compiler warnings removal - extra parenthesis added*/ dvStatus.line2 = (T_MFW_CFLAG_STATUS)(( ptr[i] >> 4 ) & 0x0F); break; case 1: dvStatus.fax = (T_MFW_CFLAG_STATUS)(ptr[i] & 0x0F); dvStatus.data = (T_MFW_CFLAG_STATUS)(( ptr[i] >> 4 ) & 0x0F); break; default: break; } } /* PATCH VO 22.01.01 END */ } TRACE_EVENT("CPHS valid call forwrading status"); cphs_signal(E_CPHS_GET_DV_STAT, &dvStatus); } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_als | +-----------------------------------------------------------------------+ PURPOSE : Read alternate line service */ void cphs_read_als(USHORT errCode, UBYTE *data, UBYTE dataLen) { TRACE_FUNCTION ("cphs_read_als()"); } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_alss | +-----------------------------------------------------------------------+ PURPOSE : Read alternate line service status */ void cphs_read_alss(USHORT errCode, UBYTE *data, UBYTE dataLen) { TRACE_FUNCTION ("cphs_read_alss()"); } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_csp | +-----------------------------------------------------------------------+ PURPOSE : Read customer service profile */ void cphs_read_csp(USHORT errCode, UBYTE *data, UBYTE dataLen) { UBYTE *ptr; UBYTE flag; int i; TRACE_FUNCTION ("cphs_read_csp()"); ptr = data; #ifdef FF_2TO1_PS if ( errCode NEQ CAUSE_SIM_NO_ERROR OR #else if ( errCode NEQ SIM_NO_ERROR OR #endif ptr EQ NULL OR dataLen <= 0 ) /* PATCH VO 22.01.01: not check a certain length */ { if (simStatus EQ MFW_SIMOP_READ_OK) /* Used for read information numbers */ { simStatus = MFW_SIMOP_UNKNOWN; cphs_signal(E_CPHS_GET_INFO_LIST, &numList); } else { csProfile.result = MFW_SIMOP_READ_ERR; memset(csProfile.csp, 0, sizeof(csProfile.csp)); cphs_signal(E_CPHS_GET_CSP, &csProfile); } } else { if (simStatus EQ MFW_SIMOP_READ_OK) /* Used for read information numbers */ { simStatus = MFW_SIMOP_UNKNOWN; /* check the service group code */ flag = 0; for (i = 0; i < dataLen; i += 2) /* PATCH VO 22.01.01: use the actual length in the SIM card */ { if (ptr[i] EQ 0xD5 AND ptr[i+1] EQ 0xFF) flag = 1; } if (!flag) { cphs_signal(E_CPHS_GET_INFO_LIST, &numList); return; } /* Read the first information numbers record */ if (!cphs_read_sim_rcd(SIM_CPHS_INFN, 1, 0)) cphs_signal(E_CPHS_GET_INFO_LIST, &numList); else cphsPrevRead = SIM_CPHS_INFN; } else { csProfile.result = MFW_SIMOP_READ_OK; TRACE_EVENT("CPHS valis CSP"); memcpy(csProfile.csp, ptr, sizeof(csProfile.csp)); cphs_signal(E_CPHS_GET_CSP, &csProfile); } } } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_req_info_num_read | +------------------------------------------------------------------------+ PURPOSE : Read customer service profile */ void cphs_req_info_num_read(UBYTE rcd_num, UBYTE dataLen) { TRACE_FUNCTION ("cphs_req_info_num_read()"); if (rcd_num > maxRec) cphs_signal(E_CPHS_GET_INFO_LIST, &numList); else { if (cphsPrevRead == SIM_CPHS_INFN) { if (!cphs_read_sim_rcd(SIM_CPHS_INFN, rcd_num, dataLen)) { cphs_signal(E_CPHS_GET_INFO_LIST, &numList); } else { cphsPrevRead = SIM_CPHS_INFN; } } else { if (cphsPrevRead == SIM_CPHS_INFN2) { if (!cphs_read_sim_rcd(SIM_CPHS_INFN2, rcd_num, dataLen)) { cphs_signal(E_CPHS_GET_INFO_LIST, &numList); } else { cphsPrevRead = SIM_CPHS_INFN2; } } } } } /* +--------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_first_info_num | +--------------------------------------------------------------------------+ PURPOSE : Read first record of information numbers */ void cphs_read_first_info_num(SHORT table_id) { UBYTE dataLen; TRACE_FUNCTION ("cphs_read_first_info_num()"); #ifdef FF_2TO1_PS if ( simShrdPrm.atb[table_id].errCode NEQ CAUSE_SIM_NO_ERROR ) /* VO patch 040501 - remove dataLen and pData check */ #else if ( simShrdPrm.atb[table_id].errCode NEQ SIM_NO_ERROR ) /* VO patch 040501 - remove dataLen and pData check */ #endif { if (simStatus EQ MFW_SIMOP_READ_OK) /* Read entry of information numbers */ { simStatus = MFW_SIMOP_UNKNOWN; infoEntry.result = MFW_SIMOP_READ_ERR; cphs_signal(E_CPHS_GET_INFO_NUM, &infoEntry); } else {// if we are here then its possible the read of 7F20 6F19 failed. if (cphsPrevRead == SIM_CPHS_INFN) { if (!cphs_read_sim_rcd(SIM_CPHS_INFN2, 1, 0)) { infoEntry.result = MFW_SIMOP_READ_ERR; cphs_signal(E_CPHS_GET_INFO_LIST, &infoEntry); } else { cphsPrevRead = SIM_CPHS_INFN2; } } else { cphs_signal(E_CPHS_GET_INFO_LIST, &numList); } } } else { maxRec = simShrdPrm.atb[table_id].recMax; dataLen = simShrdPrm.atb[table_id].dataLen; if (simStatus EQ MFW_SIMOP_READ_OK) /* Read entry of information numbers */ { /* VO patch 040501 - add dataLen check: if (patch) else ... */ if (dataLen < MFW_CPHS_MIN_INS_SIZE ) { simStatus = MFW_SIMOP_UNKNOWN; infoEntry.result = MFW_SIMOP_READ_ERR; cphs_signal(E_CPHS_GET_INFO_NUM, &infoEntry); } else cphs_req_info_num_read(startIdx, dataLen); } else /* Read list of information numbers */ { /* VO patch 040501 - add dataLen check: if (patch) else ... */ if (dataLen < MFW_CPHS_MIN_INS_SIZE ) cphs_signal(E_CPHS_GET_INFO_LIST, &numList); else { if (idxLevel EQ 1) /* read this entry */ cphs_read_info_num(table_id); else /* read the startIndex record */ cphs_req_info_num_read(startIdx, dataLen); } } } } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_info_num | +---------------------------------------------------------------------+ PURPOSE : Read first record of information numbers */ void cphs_read_info_num(SHORT table_id) { UBYTE* pData; /* points to data buffer */ UBYTE dataLen; UBYTE alphaLen; UBYTE recNr; T_ACI_TOA type; TRACE_FUNCTION ("cphs_read_info_num()"); pData = simShrdPrm.atb[table_id].exchData; dataLen = simShrdPrm.atb[table_id].dataLen; recNr = simShrdPrm.atb[table_id].recNr; #ifdef FF_2TO1_PS if ( simShrdPrm.atb[table_id].errCode NEQ CAUSE_SIM_NO_ERROR OR #else if ( simShrdPrm.atb[table_id].errCode NEQ SIM_NO_ERROR OR #endif pData EQ NULL OR dataLen < MFW_CPHS_MIN_INS_SIZE ) { if (simStatus EQ MFW_SIMOP_READ_OK) /* Read entry of information numbers */ { simStatus = MFW_SIMOP_UNKNOWN; infoEntry.result = MFW_SIMOP_READ_ERR; cphs_signal(E_CPHS_GET_INFO_NUM, &infoEntry); } else {// if we are here then its possible the read of 7F20 6F19 failed. // so we must try reading 7F10 EA01 instead. if (cphsPrevRead == SIM_CPHS_INFN2) { if (!cphs_read_sim_rcd(SIM_CPHS_INFN2, 1, 0)) { infoEntry.result = MFW_SIMOP_READ_ERR; cphs_signal(E_CPHS_GET_INFO_LIST, &infoEntry); } else { cphsPrevRead = SIM_CPHS_INFN2; } } else { cphs_signal(E_CPHS_GET_INFO_LIST, &numList); } } cphs_signal(E_CPHS_GET_INFO_LIST, &numList); // correct ??? VO } else { if (simStatus EQ MFW_SIMOP_READ_OK) { /* Read entry of information numbers */ alphaLen = *pData; if (alphaLen) { /* copy/encode entry */ infoEntry.index = recNr; infoEntry.entryStat = *(pData + 1); cmhPHB_getMfwTagNt(pData + 2, alphaLen, infoEntry.alpha.data, &infoEntry.alpha.len); pData += alphaLen + 2; if (*pData NEQ 0xFF) { cmhPHB_getAdrStr ( (CHAR *)infoEntry.number, 3, /* length of number */ pData + 2, *pData ); cmhPHB_toaDmrg ( *( pData + 1 ), &type ); infoEntry.ton = phb_cvtTon(type.ton); infoEntry.npi = phb_cvtNpi(type.npi); infoEntry.entryStat = infoEntry.entryStat | 0x80; } else { infoEntry.number[0] = '\0'; infoEntry.ton = MFW_TON_UNKNOWN; infoEntry.npi = MFW_NPI_UNKNOWN; } } infoEntry.result = MFW_SIMOP_READ_OK; cphs_signal(E_CPHS_GET_INFO_NUM, &infoEntry); return; } else if ((*(pData + 1) & 0x0F) < idxLevel) { /* The index level is out the wished index level. */ cphs_signal(E_CPHS_GET_INFO_LIST, &numList); } else if ((*(pData + 1) & 0x0F) > idxLevel) { /* This is not wished index level. Read the next */ recNr++; cphs_req_info_num_read(recNr, dataLen); } else { /* This is the wished index level. Read it. */ alphaLen = *pData; if (alphaLen) /* check alpha length */ { /* copy/encode this entry in list */ numList.level = idxLevel; numList.entry[numList.count].index = recNr; numList.entry[numList.count].entryStat = *(pData + 1) & 0x7F; /* set bit 8 to 0 */ cmhPHB_getMfwTagNt(pData + 2, alphaLen, numList.entry[numList.count].alpha.data, &numList.entry[numList.count].alpha.len); pData += alphaLen + 2; if (*pData NEQ 0xFF) { numList.entry[numList.count].entryStat = numList.entry[numList.count].entryStat | 0x80; } numList.count++; } recNr++; /* Read the next record */ cphs_req_info_num_read(recNr, dataLen); } } } /* +--------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_eeprom_mailbox | +--------------------------------------------------------------------------+ PURPOSE : Read mailbox number from EEPROM */ void cphs_read_eeprom_mailbox(void) { U8 version; #ifdef PCM_2_FFS T_PSPDF_MBN mbn; #else EF_MBN mbn; #endif T_ACI_TOA numTp; int i; USHORT max_rcd; for (i=0; i<MAX_CPHS_ENTRY; i++) { #ifdef PCM_2_FFS if (ffs_ReadRecord((UBYTE *)PSPDF_MBN_ID, (UBYTE *)&mbn, sizeof( T_PSPDF_MBN ), (USHORT)(i+1), 1 ) == sizeof( T_PSPDF_MBN ) ) #else if (pcm_ReadRecord((UBYTE *)EF_MBN_ID, (USHORT)(i+1), SIZE_EF_MBN, (UBYTE *)&mbn, &version, &max_rcd) == PCM_OK) #endif { if (mbn.len) { mbNum.entries[mbNum.count].index = i+1; cmhPHB_getAdrStr ( (char *)mbNum.entries[mbNum.count].number, PHB_MAX_LEN - 1, mbn.mbNum, mbn.len ); cmhPHB_getMfwTagNt ( mbn.alphId, 10, mbNum.entries[mbNum.count].alpha.data, &mbNum.entries[mbNum.count].alpha.len ); cmhPHB_toaDmrg ( mbn.numTp, &numTp ); mbNum.entries[mbNum.count].ton = phb_cvtTon(numTp.ton); mbNum.entries[mbNum.count].npi = phb_cvtNpi(numTp.npi); mbNum.entries[mbNum.count].service = i; mbNum.count++; } } } cphs_signal(E_CPHS_GET_VC_NUM, &mbNum); } /* +---------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_write_eeprom_mailbox | +---------------------------------------------------------------------------+ PURPOSE : Write mailbox number in EEPROM */ void cphs_write_eeprom_mailbox(T_MFW_CPHS_ENTRY *entry) { T_ACI_PB_TEXT text; UBYTE len; //EF_MBN mbn; T_ACI_TOA type; UBYTE *pNumber; UBYTE result; UBYTE outLen; len = MINIMUM ( MAX_PCM_MAILBOX_LEN, entry->alpha.len); text.len = len; memcpy(text.data, entry->alpha.data, len); text.cs = CS_Sim; cmhPHB_getMfwTagSim ( &text, FFS_flashData.mbn_AlphId, &outLen, MAX_PCM_MAILBOX_LEN ); if ( entry->number[0] EQ '+') { type.ton = TON_International; pNumber = &entry->number[1]; } else { type.ton = (T_ACI_TOA_TON)entry->ton;/*a0393213 warnings removal-explicit typecasting done*/ pNumber = &entry->number[0]; } type.npi = (T_ACI_TOA_NPI)entry->npi;/*a0393213 warnings removal-explicit typecasting done*/ //MC- switching from PCM to FFS cmhPHB_toaMrg ( &type, /*&mbn.numTp*/&FFS_flashData.mbn_numTp ); cmhPHB_getAdrBcd ((UBYTE*) FFS_flashData.mbn_Num/*mbn.mbNum*/, /*&mbn.len*/&FFS_flashData.mbn_len, MAX_PCM_MAILBOX_LEN, (CHAR *)pNumber ); FFS_flashData.mbn_len/*mbn.len*/++; if (flash_write() == EFFS_OK) result = MFW_SIMOP_WRITE_OK; else result = MFW_SIMOP_WRITE_ERR; cphs_signal(E_CPHS_SET_VC_NUM, &result); } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_read_eeprom_als | +-----------------------------------------------------------------------+ PURPOSE : Read alternate line service information from EEPROM */ void cphs_read_eeprom_als(T_MFW_CPHS_ALS_STATUS *info) { #ifdef PCM_2_FFS T_PSPDF_ALS alsInfo; #else EF_ALS alsInfo; #endif // UBYTE version; // RAVI TRACE_FUNCTION ("cphs_read_eeprom_als()"); alsInfo.selLine = FFS_flashData.als_selLine; alsInfo.statLine = FFS_flashData.als_statLine; { switch (alsInfo.selLine) { case MFW_SERV_LINE1: alsStatus.selectedLine = MFW_SERV_LINE1; break; case MFW_SERV_LINE2: alsStatus.selectedLine = MFW_SERV_LINE2; break; default: alsStatus.selectedLine = MFW_SERV_LINE2; break; } switch (alsInfo.statLine) { case MFW_LINE_LOCKED: alsStatus.status = MFW_LINE_LOCKED; break; case MFW_LINE_UNLOCKED: alsStatus.status = MFW_LINE_UNLOCKED; break; default: alsStatus.status = MFW_LINE_UNLOCKED; break; } } info->selectedLine = alsStatus.selectedLine; info->status = alsStatus.status; } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_write_eeprom_als | +-----------------------------------------------------------------------+ PURPOSE : Write selected alternate line in EEPROM */ void cphs_write_eeprom_als(UBYTE *res) { /*a0393213 compiler warnings removal - variable alsinfo deleted*/ TRACE_FUNCTION ("cphs_write_eeprom_als()"); { if (alsStatus.status EQ MFW_LINE_LOCKED) *res = MFW_SIMOP_WRITE_ERR; alsStatus.selectedLine = (T_MFW_LINE_INDEX)alsData; FFS_flashData.als_selLine = alsData; if (flash_write() == EFFS_OK) *res = MFW_SIMOP_WRITE_OK; else *res = MFW_SIMOP_WRITE_ERR; } } /* +-----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_write_eeprom_alss| +-----------------------------------------------------------------------+ PURPOSE : Write line lock status in EEPROM */ void cphs_write_eeprom_alss(UBYTE *res) { /*a0393213 compiler warnings removal - variable alsinfo removed*/ TRACE_FUNCTION ("cphs_write_eeprom_als()"); { alsStatus.status = (T_MFW_LINE_STATUS)alsData; FFS_flashData.als_statLine = alsData; if (flash_write() == EFFS_OK) *res = MFW_SIMOP_WRITE_OK; else *res = MFW_SIMOP_WRITE_ERR; } } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_read_sim_dat | +----------------------------------------------------------------------+ PURPOSE : Request to read SIM card. */ BOOL cphs_read_sim_dat(USHORT data_id, UBYTE len, UBYTE max_length) { T_ACI_RETURN res; TRACE_FUNCTION ("cphs_read_sim_dat()"); #ifdef FF_2TO1_PS res = cmhSIM_ReadTranspEF ( CMD_SRC_NONE, AT_CMD_NONE, FALSE, /* SCT: dummy only (path info valid flag) */ NULL, /* SCT: dummy only (path info)*/ data_id, 0, max_length, NULL, cphs_read_sim_dat_cb); #else res = cmhSIM_ReadTranspEF ( CMD_SRC_NONE, AT_CMD_NONE, FALSE, /* SCT: dummy only (path info valid flag) */ NULL, /* SCT: dummy only (path info)*/ data_id, 0, max_length, NULL, cphs_read_sim_dat_cb); #endif if (res NEQ AT_EXCT) return FALSE; return TRUE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_read_sim_dat_cb | +----------------------------------------------------------------------+ PURPOSE : Call back for SIM read. */ void cphs_read_sim_dat_cb(SHORT table_id) { UBYTE dataLen; UBYTE result; TRACE_FUNCTION ("cphs_read_sim_dat_cb()"); /***************************Go-lite Optimization changes Start***********************/ //Aug 16, 2004 REF: CRR 24323 Deepa M.D TRACE_EVENT_P1("SIM Error code!!!%d",simShrdPrm.atb[table_id].errCode); /***************************Go-lite Optimization changes end***********************/ switch (simShrdPrm.atb[table_id].reqDataFld) { case SIM_CPHS_CINF: /* CPHS information */ if (!cphsUpdate) cphs_read_information(simShrdPrm.atb[table_id].errCode, simShrdPrm.atb[table_id].exchData, simShrdPrm.atb[table_id].dataLen); #ifdef SIM_TOOLKIT else cphs_update_info_cnf(simShrdPrm.atb[table_id].errCode, simShrdPrm.atb[table_id].exchData, simShrdPrm.atb[table_id].dataLen); #endif break; case SIM_CPHS_ONSTR: /* operator name string */ cphs_read_ons(simShrdPrm.atb[table_id].errCode, simShrdPrm.atb[table_id].exchData, simShrdPrm.atb[table_id].dataLen); break; case SIM_CPHS_ONSHF: /* operator name short form */ cphs_read_onsf(simShrdPrm.atb[table_id].errCode, simShrdPrm.atb[table_id].exchData, simShrdPrm.atb[table_id].dataLen); break; case SIM_CPHS_VMW: /* voice message waiting flag */ /* PATCH VO 22.01.01 */ if (simStatus EQ MFW_SIMOP_WRITE_OK) { /* Determine the size of this field, and write the data. When the writing is not possible, write this voice message waiting flag in EEPROM. */ simStatus = MFW_SIMOP_UNKNOWN; #ifdef FF_2TO1_PS if ( simShrdPrm.atb[table_id].errCode EQ CAUSE_SIM_NO_ERROR ) #else if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR ) #endif { dataLen = simShrdPrm.atb[table_id].dataLen; /* Write voice message waiting flag. When this writing failed, send event with "write error" parameter to MMI */ if (!cphs_write_sim_dat(SIM_CPHS_VMW, mbsData, dataLen)) { result = MFW_SIMOP_WRITE_ERR; cphs_signal(E_CPHS_SET_VC_STAT, &result); } } else { result = MFW_SIMOP_WRITE_ERR; cphs_signal(E_CPHS_SET_VC_STAT, &result); } } else /* PATCH VO 22.01.01 end */ cphs_read_mbs (simShrdPrm.atb[table_id].errCode, simShrdPrm.atb[table_id].exchData, simShrdPrm.atb[table_id].dataLen); break; case SIM_CPHS_CFF: /* call forwarding flag */ /* PATCH VO 22.01.01 */ if (simStatus EQ MFW_SIMOP_WRITE_OK) { /* Determine the size of this field, and write the data. When the writing is not possible, write this call forward flag in EEPROM*/ simStatus = MFW_SIMOP_UNKNOWN; #ifdef FF_2TO1_PS if ( simShrdPrm.atb[table_id].errCode EQ CAUSE_SIM_NO_ERROR ) #else if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR ) #endif { dataLen = simShrdPrm.atb[table_id].dataLen; /* Write call forwarding flag. When this writing failed, send event with "write error" parameter to MMI */ TRACE_EVENT_P2("cphs_read_sim_dat_cb():%x %x",dvData[0],dvData[1]); if (!cphs_write_sim_dat(SIM_CPHS_CFF, dvData, dataLen)) { result = MFW_SIMOP_WRITE_ERR; cphs_signal(E_CPHS_SET_DV_STAT, &result); } } else { result = MFW_SIMOP_WRITE_ERR; /*May 30, 2006 REF:OMAPS00079650 a0393213 (R.Prabakar) Description : CPHS Call Forwarding feature implementation Solution : As part of the implementation, a typographical error is corrected. E_CPHS_SET_VC_STAT was changed to E_CPHS_SET_DV_STAT*/ cphs_signal(E_CPHS_SET_DV_STAT, &result); } } else /* PATCH VO 22.01.01 end */ cphs_read_cff (simShrdPrm.atb[table_id].errCode, simShrdPrm.atb[table_id].exchData, simShrdPrm.atb[table_id].dataLen); break; case SIM_CPHS_CSP: /* customer service profile */ cphs_read_csp (simShrdPrm.atb[table_id].errCode, simShrdPrm.atb[table_id].exchData, simShrdPrm.atb[table_id].dataLen); break; default: break; } simShrdPrm.atb[table_id].ntryUsdFlg = FALSE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_write_sim_dat | +----------------------------------------------------------------------+ PURPOSE : Request to write SIM card. */ BOOL cphs_write_sim_dat(USHORT data_id, UBYTE *data, UBYTE length) { T_ACI_RETURN res; TRACE_FUNCTION ("cphs_write_sim_dat()"); #ifdef FF_2TO1_PS res = cmhSIM_WriteTranspEF (CMD_SRC_NONE, AT_CMD_NONE, FALSE, /* SCT: dummy only (path info valid flag) */ NULL, /* SCT: dummy only (path info) */ data_id, 0, length, data, cphs_write_sim_dat_cb); #else res = cmhSIM_WriteTranspEF (CMD_SRC_NONE, AT_CMD_NONE, FALSE, /* SCT: dummy only (path info valid flag) */ NULL, /* SCT: dummy only (path info) */ data_id, 0, length, data, cphs_write_sim_dat_cb); #endif if (res NEQ AT_EXCT) return FALSE; return TRUE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_write_sim_dat_cb | +----------------------------------------------------------------------+ PURPOSE : callback of SIM card writing. */ void cphs_write_sim_dat_cb(SHORT table_id) { UBYTE result; TRACE_FUNCTION ("sim_write_sim_dat_cb()"); /***************************Go-lite Optimization changes Start***********************/ //Aug 16, 2004 REF: CRR 24323 Deepa M.D TRACE_EVENT_P1("SIM Error code!!!%d", simShrdPrm.atb[table_id].errCode); /***************************Go-lite Optimization changes end***********************/ switch (simShrdPrm.atb[table_id].reqDataFld) { case SIM_CPHS_VMW: /* voice message waiting flag */ #ifdef FF_2TO1_PS if ( simShrdPrm.atb[table_id].errCode EQ CAUSE_SIM_NO_ERROR ) #else if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR ) #endif { result = MFW_SIMOP_WRITE_OK; cphs_signal(E_CPHS_SET_VC_STAT, &result); } else { result = MFW_SIMOP_WRITE_ERR; cphs_signal(E_CPHS_SET_VC_STAT, &result); } break; case SIM_CPHS_CFF: /* call forwarding flag */ #ifdef FF_2TO1_PS if ( simShrdPrm.atb[table_id].errCode EQ CAUSE_SIM_NO_ERROR ) #else if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR ) #endif { result = MFW_SIMOP_WRITE_OK; cphs_signal(E_CPHS_SET_DV_STAT, &result); } else { result = MFW_SIMOP_WRITE_ERR; cphs_signal(E_CPHS_SET_DV_STAT, &result); } break; default: break; } simShrdPrm.atb[table_id].ntryUsdFlg = FALSE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_read_sim_rcd | +----------------------------------------------------------------------+ PURPOSE : Request to read SIM card. */ BOOL cphs_read_sim_rcd(USHORT data_id, UBYTE rcd_num, UBYTE len) { T_ACI_RETURN res; UBYTE dataLen; TRACE_FUNCTION ("cphs_read_sim_rcd()"); TRACE_EVENT_P1("rec num to be read: %d", rcd_num); if (rcd_num EQ 1) dataLen = UCHAR_MAX; else dataLen = len; #ifdef FF_2TO1_PS res = cmhSIM_ReadRecordEF ( CMD_SRC_NONE, AT_CMD_NONE, TRUE, /* SCT: dummy only (path info valid flag) */ NULL, /* SCT: dummy only (path info) */ data_id, rcd_num, dataLen, NULL, cphs_read_sim_rcd_cb); #else res = cmhSIM_ReadRecordEF ( CMD_SRC_NONE, AT_CMD_NONE, FALSE, /* SCT: dummy only (path info valid flag) */ NULL, /* SCT: dummy only (path info) */ data_id, rcd_num, dataLen, NULL, cphs_read_sim_rcd_cb); #endif if (res NEQ AT_EXCT) return FALSE; return TRUE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_read_sim_rcd_cb | +----------------------------------------------------------------------+ PURPOSE : Request to read SIM card. */ void cphs_read_sim_rcd_cb (SHORT table_id) { UBYTE dataLen; TRACE_FUNCTION ("cphs_read_sim_rcd_cb()"); /***************************Go-lite Optimization changes Start***********************/ //Aug 16, 2004 REF: CRR 24323 Deepa M.D TRACE_EVENT_P1("SIM Error code!!!%d", simShrdPrm.atb[table_id].errCode); TRACE_EVENT_P1("tableid: %d", table_id); /***************************Go-lite Optimization changes end***********************/ switch (simShrdPrm.atb[table_id].reqDataFld) { case SIM_CPHS_MBXN: /* mailbox numbers */ if (simStatus EQ MFW_SIMOP_WRITE_OK) { /* Determine the size of record, and write a new record. When the writing is not possible, write this mailbox number in EEPROM. */ simStatus = MFW_SIMOP_UNKNOWN; #ifdef FF_2TO1_PS if ( simShrdPrm.atb[table_id].errCode EQ CAUSE_SIM_NO_ERROR ) #else if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR ) #endif { dataLen = simShrdPrm.atb[table_id].dataLen; /* allocate mbnData (sizeof(dataLen)) */ // Mar 30, 2005 REF: CRR 29986 xpradipg // the dynamic allocation is done here, if the write fails it is deallocated // else if success it is deallocated in the callback #ifdef FF_MMI_OPTIM mbnData = (UBYTE*)mfwAlloc(200); if(mbnData != NULL) { #endif ubCphsMbExtRecNo = 0; cphs_build_mbn_data(mbnData, dataLen); if (!cphs_write_sim_rcd(SIM_CPHS_MBXN, vcEntry->index, mbnData, dataLen)) { cphs_write_eeprom_mailbox(vcEntry); } #ifdef FF_MMI_OPTIM } #endif } else cphs_write_eeprom_mailbox(vcEntry); } else cphs_read_mbn(table_id); break; case SIM_CPHS_INFN: /* information numbers */ if (simShrdPrm.atb[table_id].recNr EQ 1) { /* VO patch 150501 */ if ((startIdx EQ 1) AND (simStatus EQ MFW_SIMOP_READ_OK)) cphs_read_info_num(table_id); else /* VO patch 150501 end */ cphs_read_first_info_num(table_id); } else cphs_read_info_num(table_id); break; case SIM_CPHS_INFN2: /* information numbers 2 - 7F10 'EA01' selected if SIM_CPHS_INFN '6F19' isn't there*/ if (simShrdPrm.atb[table_id].recNr EQ 1) { /* VO patch 150501 */ if ((startIdx EQ 1) AND (simStatus EQ MFW_SIMOP_READ_OK)) cphs_read_info_num(table_id); else /* VO patch end */ cphs_read_first_info_num(table_id); } else cphs_read_info_num(table_id); break; /*June 27,2007 OMAPS00134788 x0066814(Geetha)*/ case SIM_EXT1: cphs_read_ext1(table_id); break; default: break; } simShrdPrm.atb[table_id].ntryUsdFlg = FALSE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_write_sim_rcd | +----------------------------------------------------------------------+ PURPOSE : Request to write SIM card. */ BOOL cphs_write_sim_rcd(USHORT data_id, UBYTE rcd_num, UBYTE *data, UBYTE dataLen) { T_ACI_RETURN res; TRACE_FUNCTION ("cphs_read_sim_rcd()"); #ifdef FF_2TO1_PS res = cmhSIM_WriteRecordEF (CMD_SRC_NONE, AT_CMD_NONE, TRUE, /* SCT: dummy only (path info valid flag) */ NULL, /* SCT: dummy only (path info) */ data_id, rcd_num, dataLen, data, cphs_write_sim_rcd_cb); #else res = cmhSIM_WriteRecordEF (CMD_SRC_NONE, AT_CMD_NONE, FALSE, /* SCT: dummy only (path info valid flag) */ NULL, /* SCT: dummy only (path info) */ data_id, rcd_num, dataLen, data, cphs_write_sim_rcd_cb); #endif if (res NEQ AT_EXCT) return FALSE; return TRUE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_build_ext1 | +----------------------------------------------------------------------+ PURPOSE : Frame the data as per the EXT1 record structure */ UBYTE *temp_data = NULL; UBYTE cphs_build_ext1(UBYTE *pData) { UBYTE count = 0; UBYTE ext1num[PHB_MAX_LEN]; UBYTE indx = 0; SHORT rec_no_to_write = 0; UBYTE numLen; UBYTE *pNumber; UBYTE i, j; unsigned int length_no = 0; UBYTE byteno = 0; TRACE_FUNCTION ( "cphs_build_ext1()" ); memset( pData, MFW_INVALID_SIM_DATA, 13); *pData = 0x02; //implies that the EF contains additional data temp_data = pData; /* number data and TON/NPI data */ if ( vcEntry->number[0] EQ '+' ) { vcEntry->ton = TON_International; pNumber = &vcEntry->number[1]; } else pNumber = &vcEntry->number[0]; cmhPHB_getAdrBcd ( ext1num, &numLen, PHB_MAX_LEN - 1, (CHAR *) (pNumber)); for(i=0; i < strlen((CHAR *)pNumber); i++) { TRACE_EVENT_P2("pNumber[%d] : %c", i,pNumber[i]); } length_no = numLen; //strlen( (CHAR *)pNumber ); byteno = numLen; //( length_no / 2 ) + ( length_no % 2 ); indx = ( (ubCurrExtRcWrite + 1) * 10 ); TRACE_EVENT_P1("length_no: %d", length_no); TRACE_EVENT_P1("indx: %d", indx); if ( ( byteno - indx ) > 10 ) { count = 10; } else { count = ( byteno - indx ); } TRACE_EVENT_P1("count: %d", count); if ( count != 0 ) { memcpy ( (void *)(pData + 2), (void *)&(ext1num[indx]), ( count ) ); } for(i=0; i < count; i++) { TRACE_EVENT_P2("pData + 2 + %d : %x", i, *(pData + 2+i)); } *(pData+1) = ( count ); pData += 12; mbNum.entries[vcEntry->list_index].ext_rec_idx[ubCurrExtRcWrite] = sFreeRec; TRACE_EVENT_P1("ubCurrExtRcWrite: %d", ubCurrExtRcWrite); TRACE_EVENT_P1("mbNum...ext_rec_idx[ubCurrExtRcWrite]: %d", mbNum.entries[vcEntry->list_index].ext_rec_idx[ubCurrExtRcWrite]); ubCurrExtRcWrite++; if ( ubCphsMbExtRecNo <= ubCurrExtRcWrite ) { if ( ( sFreeRec <= 0 ) || ( sFreeRec == 0xFF ) ) { TRACE_FUNCTION ("cphs_build_ext1() : ubCphsMbExtRecNo <= ubCurrExtRcWrite; no free rec"); *(pData) = 0xFF; return FALSE; } rec_no_to_write = sFreeRec; *(pData) = 0xFF; } else { rec_no_to_write = sFreeRec; sFreeRec = 0; if ( mbNum.entries[vcEntry->list_index].ext_rec_number > ubCurrExtRcWrite ) { TRACE_FUNCTION("ext rec taken from within"); sFreeRec = mbNum.entries[vcEntry->list_index].ext_rec_idx[ubCurrExtRcWrite]; } else { TRACE_FUNCTION("ext rec taken from cmh"); #ifdef TI_PS_FFS_PHB sFreeRec = cmh_Query_free_ext_record(); #endif } TRACE_EVENT_P1("sFreeRec : %d", sFreeRec); if ( ( sFreeRec <= 0 ) || ( sFreeRec == 0xFF ) ) { TRACE_FUNCTION ("cphs_build_ext1() : No free records available"); *(pData) = 0xFF; } else { *(pData) = 0x00; *(pData) = sFreeRec; TRACE_FUNCTION("cmh_PHB_update_ext_record to be"); #ifdef TI_PS_FFS_PHB cmh_PHB_update_ext_record(sFreeRec,TRUE); #endif } mbNum.entries[vcEntry->list_index].ext_rec_idx[ubCurrExtRcWrite] = *(pData); } TRACE_EVENT_P1("rec_no_to_write : %d", rec_no_to_write); cphs_write_sim_rcd(SIM_EXT1, rec_no_to_write, temp_data, 13); return TRUE; } static UBYTE mfw_cphs_vm_write_cb_ext(void) { UBYTE ret_internal = 0; UBYTE result; TRACE_FUNCTION("mfw_cphs_vm_write_cb_ext"); TRACE_EVENT_P1("ubCphsMbExtRecNo : %d", ubCphsMbExtRecNo); TRACE_EVENT_P1("ubCurrExtRcWrite : %d", ubCurrExtRcWrite); TRACE_EVENT_P2("idx, ext_rec_number : %d, %d", vcEntry->list_index, mbNum.entries[vcEntry->list_index].ext_rec_number); if ( ( ubCphsMbExtRecNo == 0 ) || ( ubCphsMbExtRecNo <= ubCurrExtRcWrite ) ) { TRACE_FUNCTION("inside if!"); /* Flush any EXT Records, if any */ if ( mbNum.entries[vcEntry->list_index].ext_rec_number > ubCphsMbExtRecNo ) { TRACE_FUNCTION("flush needed!--"); if ( ubFlushRecords == 0 ) { ubFlushRecords = 1; } TRACE_EVENT_P1("ubFlushRecords : %d", ubFlushRecords); TRACE_EVENT_P1("i : %d", (ubCphsMbExtRecNo + ubFlushRecords - 1)); TRACE_EVENT_P1("ext_rec_idx[i] : %d", mbNum.entries[vcEntry->list_index].ext_rec_idx[ubCphsMbExtRecNo + ubFlushRecords - 1]); memset ( (void *)&flush_data[0], 0xFF, 13 ); #ifdef TI_PS_FFS_PHB cmh_PHB_update_ext_record(mbNum.entries[vcEntry->list_index].ext_rec_idx[ubCphsMbExtRecNo + ubFlushRecords - 1], FALSE); #endif cphs_write_sim_rcd(SIM_EXT1, mbNum.entries[vcEntry->list_index].ext_rec_idx[ubCphsMbExtRecNo + ubFlushRecords - 1], flush_data, 13); mbNum.entries[vcEntry->list_index].ext_rec_idx[ubCphsMbExtRecNo + ubFlushRecords - 1] = 0xFF; mbNum.entries[vcEntry->list_index].ext_rec_number--; ubFlushRecords++; return 1; } ubFlushRecords = 0; result = MFW_SIMOP_WRITE_OK; TRACE_FUNCTION("mfw_cphs_vm_write_cb_ext: write OK"); cphs_signal(E_CPHS_SET_VC_NUM, &result); // Mar 30, 2005 REF: CRR 29986 xpradipg // mbnData is deallocated, on successfull write operation #ifdef FF_MMI_OPTIM if(mbnData) mfwFree(mbnData,200); #endif return 0; } else { ret_internal = cphs_build_ext1(ubExtRecData); if ( ret_internal == FALSE ) { TRACE_FUNCTION("mfw_cphs_vm_write_cb_ext: cphs_build_ext1 returns FALSE"); result = MFW_SIMOP_WRITE_OK; cphs_signal(E_CPHS_SET_VC_NUM, &result); // Mar 30, 2005 REF: CRR 29986 xpradipg // mbnData is deallocated, on successfull write operation #ifdef FF_MMI_OPTIM if(mbnData) mfwFree(mbnData,200); #endif return 0; } } return 1; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_write_sim_rcd_cb | +----------------------------------------------------------------------+ PURPOSE : callback of SIM card writing. */ void cphs_write_sim_rcd_cb (SHORT table_id) { UBYTE result; UBYTE *data_write; UBYTE dataLen = 0; UBYTE ret_internal = 0; TRACE_FUNCTION ("cphs_write_sim_rcd_cb()"); /***************************Go-lite Optimization changes Start***********************/ //Aug 16, 2004 REF: CRR 24323 Deepa M.D TRACE_EVENT_P1("SIM Error code!!!%d", simShrdPrm.atb[table_id].errCode); /***************************Go-lite Optimization changes end***********************/ switch (simShrdPrm.atb[table_id].reqDataFld) { case SIM_CPHS_MBXN: /* mailbox numbers */ #ifdef FF_2TO1_PS if ( simShrdPrm.atb[table_id].errCode EQ CAUSE_SIM_NO_ERROR ) #else if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR ) #endif { result = MFW_SIMOP_WRITE_OK; ret_internal = mfw_cphs_vm_write_cb_ext(); if ( ret_internal == 1 ) { return; } } else { cphs_write_eeprom_mailbox(vcEntry); } break; case SIM_EXT1: /* mailbox ext numbers */ #ifdef FF_2TO1_PS if ( simShrdPrm.atb[table_id].errCode EQ CAUSE_SIM_NO_ERROR ) #else if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR ) #endif { result = MFW_SIMOP_WRITE_OK; ret_internal = mfw_cphs_vm_write_cb_ext(); if ( ret_internal == 1 ) { return; } } else { cphs_write_eeprom_mailbox(vcEntry); } break; default: break; } simShrdPrm.atb[table_id].ntryUsdFlg = FALSE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_build_mbn_data | +----------------------------------------------------------------------+ PURPOSE : Build mailbox number data in SIM format. */ BOOL cphs_build_mbn_data(UBYTE *data, UBYTE len) { UBYTE alphaLen; UBYTE numLen; UBYTE *pNumber; UBYTE i, j; unsigned int length_no = 0; UBYTE byteno = 0; TRACE_FUNCTION ("cphs_build_mbn_data()"); memset(data, MFW_INVALID_SIM_DATA, len); /* alpha data */ if (len <= MFW_CPHS_MIN_MBN_SIZE) alphaLen = 0; else alphaLen = len - MFW_CPHS_MIN_MBN_SIZE; i = MINIMUM (alphaLen, vcEntry->alpha.len); for ( j = 0; j < i; j++ ) data[j] = vcEntry->alpha.data[j]; data += alphaLen; /* number data and TON/NPI data */ if ( vcEntry->number[0] EQ '+' ) { vcEntry->ton = TON_International; pNumber = &vcEntry->number[1]; } else pNumber = &vcEntry->number[0]; for(i=0; i < strlen((CHAR *)pNumber); i++) { TRACE_EVENT_P2("pNumber[%d] : %c", i,pNumber[i]); } cmhPHB_getAdrBcd ( data + 2, &numLen, PHB_MAX_LEN - 1, (CHAR *)pNumber ); for(i=0; i < numLen; i++) { TRACE_EVENT_P2("data + 2 + %d : %x", i, *(data + 2+i)); } if ( numLen < 11 ) { *data = numLen + 1; } else { *data = 11; } *(data + 1) = ((( vcEntry -> ton << 4 ) & 0xF0 ) + ( vcEntry -> npi & 0x0F )) | 0x80; data += 12; length_no = numLen; byteno = length_no; // ( length_no / 2 ) + ( length_no % 2 ); if ( byteno > 10 ) { ubCphsMbExtRecNo = ( byteno / 10 ) - ( ( byteno % 10 ) == 0 ? 1 : 0 ); } TRACE_EVENT_P1("length_no : %d", length_no); TRACE_EVENT_P1("byteno : %d", byteno); TRACE_EVENT_P1("ubCphsMbExtRecNo : %d", ubCphsMbExtRecNo); TRACE_EVENT_P1("vcEntry->index : %d", vcEntry->index); TRACE_EVENT_P1("vcEntry->list_index : %d", vcEntry->list_index); TRACE_EVENT_P1("dataLen : %d", len); TRACE_EVENT_P1("ext_rec_number : %d", mbNum.entries[vcEntry->list_index].ext_rec_number); /**************************************************************************************/ /**************************************************************************************/ /* Check if enough EXT1 Records are available for storing the current number; If not, return FALSE */ if ( ( ubCphsMbExtRecNo > 0 ) && ( mbNum.entries[vcEntry->list_index].ext_rec_number < ubCphsMbExtRecNo ) ) { for ( i = mbNum.entries[vcEntry->list_index].ext_rec_number; i < ubCphsMbExtRecNo; i++ ) { sFreeRec = 0; #ifdef TI_PS_FFS_PHB sFreeRec = cmh_Query_free_ext_record(); #endif if ( ( sFreeRec <= 0 ) || ( sFreeRec == 0xFF ) ) { sFreeRec = 0; TRACE_FUNCTION("Not enuf ext1 recs available, hence show writeerror"); return FALSE; } } sFreeRec = 0; } /**************************************************************************************/ /**************************************************************************************/ /* capability/configuration identifier data and EXT identifier data */ *data = 0xFF; if ( ubCphsMbExtRecNo == 0 ) { *(data + 1) = 0xFF; } else { sFreeRec = 0; ubCurrExtRcWrite = 0; if ( mbNum.entries[vcEntry->list_index].ext_rec_number > ubCurrExtRcWrite ) { TRACE_FUNCTION("ext rec taken from within"); sFreeRec = mbNum.entries[vcEntry->list_index].ext_rec_idx[ubCurrExtRcWrite]; } else { TRACE_FUNCTION("ext rec taken from cmh"); #ifdef TI_PS_FFS_PHB sFreeRec = cmh_Query_free_ext_record(); #endif } TRACE_EVENT_P1("sFreeRec: %d", sFreeRec); if ( ( sFreeRec <= 0 ) || ( sFreeRec == 0xFF ) ) { TRACE_FUNCTION ("cphs_build_mbn_data() : No free records available"); *(data + 1) = 0xFF; mbNum.entries[vcEntry->list_index].ext_rec_idx[ubCurrExtRcWrite] = 0xFF; } else { *(data + 1) = 0x00; *(data + 1) = sFreeRec; TRACE_FUNCTION("cmh_PHB_update_ext_record to be"); #ifdef TI_PS_FFS_PHB cmh_PHB_update_ext_record(sFreeRec,TRUE); #endif TRACE_EVENT_P1(" *(data + 1) : %d", *(data + 1) ); } mbNum.entries[vcEntry->list_index].ext_rec_idx[ubCurrExtRcWrite] = *(data + 1); } return TRUE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_ssc | +----------------------------------------------------------------------+ PURPOSE : Check CPHS service status. */ UBYTE cphs_ssc (UBYTE nr, UBYTE * serv_table) { UBYTE value; TRACE_FUNCTION ("cphs_ssc()"); serv_table = serv_table + (nr-1)/4; value = * serv_table; value = value >> (((nr-1) & 3) * 2); value = value & 3; return value; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphsCommand | +--------------------------------------------------------------------+ PURPOSE : handle mfw windows command */ static int cphsCommand (U32 cmd, void *h) { switch (cmd) { case MfwCmdDelete: /* delete me */ if (!h) return 0; cphs_delete(h); return 1; default: break; } return 0; } #ifdef SIM_TOOLKIT /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_sat_file_update | +---------------------------------------------------------------------+ PURPOSE : SIM file change indication */ void cphs_sat_file_update(USHORT dataId) { TRACE_FUNCTION("cphs_sat_file_update()"); cphsUpdate = TRUE; switch (dataId) { case SIM_CPHS_CINF: if (!cphs_read_sim_dat(SIM_CPHS_CINF, NOT_PRESENT_8BIT, MFW_CPHS_INFO_SIZE)) { satUpdateFiles(TRUE, SIM_CPHS_CINF); } break; default: break; } } #endif #ifdef SIM_TOOLKIT /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : MFW_CPHS | | STATE : code ROUTINE : cphs_update_info_cnf | +---------------------------------------------------------------------+ PURPOSE : call back for SIM file read */ void cphs_update_info_cnf (USHORT errCode, UBYTE *data, UBYTE dataLen) { UBYTE *ptr; TRACE_FUNCTION ("cphs_update_info_cnf()"); cphsUpdate = FALSE; /* reset flag */ ptr = data; #ifdef FF_2TO1_PS if ( errCode NEQ CAUSE_SIM_NO_ERROR OR #else if ( errCode NEQ SIM_NO_ERROR OR #endif ptr EQ NULL OR dataLen < MFW_CPHS_INFO_SIZE) { satUpdateFiles(TRUE, SIM_CPHS_CINF); } else { cphsPhase = *ptr; ptr++; memcpy (cphsServTab, ptr, CPHS_SERVICE_TABLE*sizeof(UBYTE)); //x0pleela 11 June, 2006 DR:OMAPS00079692 //changed from CPHS_OK to MFW_CPHS_OK cphsStatus = MFW_CPHS_OK; satUpdateFiles ( TRUE, SIM_CPHS_CINF ); } } #endif /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: Read_Sim | +----------------------------------------------------------------------+ PURPOSE : Request to read SIM card. */ BOOL Read_Sim(USHORT dat_id, USHORT offset, UBYTE max_len, UBYTE *exDat) { T_ACI_RETURN res; /* * x0047685 Added path_info to support R99 SIM Interface changes. */ T_path_info tmp_path; TRACE_FUNCTION ("Read_Sim()"); tmp_path.df_level1 = SIM_DF_VI; tmp_path.v_df_level2 = FALSE; #ifdef FF_2TO1_PS res = cmhSIM_ReadTranspEF ( CMD_SRC_NONE, AT_CMD_NONE, FALSE, /* SCT: dummy only (path info valid flag) */ NULL, /* SCT: dummy only (path info) */ dat_id, offset, max_len, exDat, cphs_read_sim_default_cb); #else res = cmhSIM_ReadTranspEF ( CMD_SRC_NONE, AT_CMD_NONE, TRUE, /* SCT: dummy only (path info valid flag) */ &tmp_path, /* SCT: dummy only (path info) */ dat_id, offset, max_len, exDat, cphs_read_sim_default_cb); #endif if (res NEQ AT_EXCT) return FALSE; return TRUE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: Read_Sim_Record | +----------------------------------------------------------------------+ PURPOSE : Request to read record from SIM card. */ BOOL Read_Sim_Record(USHORT dat_id, USHORT record, UBYTE len, UBYTE *exDat) { T_ACI_RETURN res; UBYTE dataLen; /* * x0047685 Added path_info to support R99 SIM Interface changes. */ T_path_info tmp_path; if (record EQ 1) dataLen = UCHAR_MAX; else dataLen = len; TRACE_FUNCTION ("Read_Sim_Record()"); tmp_path.df_level1 = SIM_DF_VI; tmp_path.v_df_level2 = FALSE; #ifdef FF_2TO1_PS res = cmhSIM_ReadRecordEF ( CMD_SRC_NONE, AT_CMD_NONE, FALSE, /* SCT: dummy only (path info valid flag) */ NULL, /* SCT: dummy only (path info) */ dat_id, record, dataLen, exDat, cphs_read_sim_default_cb); #else res = cmhSIM_ReadRecordEF ( CMD_SRC_NONE, AT_CMD_NONE, TRUE, /* SCT: dummy only (path info valid flag) */ &tmp_path, /* SCT: dummy only (path info) */ dat_id, record, dataLen, exDat, cphs_read_sim_default_cb); #endif if (res NEQ AT_EXCT) return FALSE; return TRUE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: Write_Sim | +----------------------------------------------------------------------+ PURPOSE : Request to write SIM card. */ BOOL Write_Sim(USHORT dat_id, UBYTE len, UBYTE *exDat) { T_ACI_RETURN res; TRACE_FUNCTION ("Write_Sim()"); #ifdef FF_2TO1_PS res = cmhSIM_WriteTranspEF (CMD_SRC_NONE, AT_CMD_NONE, FALSE, /* SCT: dummy only (path info valid flag) */ NULL, /* SCT: dummy only (path info) */ dat_id, 0, len, exDat, cphs_write_sim_default_cb); #else res = cmhSIM_WriteTranspEF (CMD_SRC_NONE, AT_CMD_NONE, FALSE, /* SCT: dummy only (path info valid flag) */ NULL, /* SCT: dummy only (path info) */ dat_id, 0, len, exDat, cphs_write_sim_default_cb); #endif if (res NEQ AT_EXCT) return FALSE; return TRUE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: Write_Sim_Record | +----------------------------------------------------------------------+ PURPOSE : Request to write record to SIM card. */ BOOL Write_Sim_Record(USHORT dat_id, USHORT record, UBYTE len, UBYTE *exDat) { T_ACI_RETURN res; /* * x0047685 Added path_info to support R99 SIM Interface changes. */ T_path_info tmp_path; TRACE_FUNCTION ("Write_Sim()"); tmp_path.df_level1 = SIM_DF_VI; tmp_path.v_df_level2 = FALSE; #ifdef FF_2TO1_PS res = cmhSIM_WriteRecordEF (CMD_SRC_NONE, AT_CMD_NONE, FALSE, /* SCT: dummy only (path info valid flag) */ NULL, /* SCT: dummy only (path info) */ dat_id, record, len, exDat, cphs_write_sim_default_cb); #else res = cmhSIM_WriteRecordEF (CMD_SRC_NONE, AT_CMD_NONE, TRUE, /* SCT: dummy only (path info valid flag) */ &tmp_path, /* SCT: dummy only (path info) */ dat_id, record, len, exDat, cphs_write_sim_default_cb); #endif if (res NEQ AT_EXCT) return FALSE; return TRUE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_read_default_cb | +----------------------------------------------------------------------+ PURPOSE : Sends event to MMI */ void cphs_read_sim_default_cb(SHORT table_id) { read_sim_entry.requested_field = simShrdPrm.atb[table_id].reqDataFld; read_sim_entry.exchange_data = simShrdPrm.atb[table_id].exchData; read_sim_entry.sim_result = simShrdPrm.atb[table_id].errCode; read_sim_entry.data_len = simShrdPrm.atb[table_id].dataLen; read_sim_entry.record = simShrdPrm.atb[table_id].recNr; #ifdef FF_2TO1_PS if (read_sim_entry.sim_result != CAUSE_SIM_NO_ERROR) #else if (read_sim_entry.sim_result != SIM_NO_ERROR) #endif { read_sim_entry.exchange_data = NULL; read_sim_entry.data_len = 0; } cphs_signal(E_CPHS_GET_SIM_FIELD, &read_sim_entry); simShrdPrm.atb[table_id].ntryUsdFlg = FALSE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: cphs_read_default_cb | +----------------------------------------------------------------------+ PURPOSE : Sends event to MMI */ void cphs_write_sim_default_cb(SHORT table_id) { read_sim_entry.requested_field = simShrdPrm.atb[table_id].reqDataFld; read_sim_entry.exchange_data = simShrdPrm.atb[table_id].exchData; read_sim_entry.sim_result = simShrdPrm.atb[table_id].errCode; read_sim_entry.data_len = simShrdPrm.atb[table_id].dataLen; #ifdef FF_2TO1_PS if (read_sim_entry.sim_result != CAUSE_SIM_NO_ERROR) #else if (read_sim_entry.sim_result != SIM_NO_ERROR) #endif { read_sim_entry.exchange_data = NULL; read_sim_entry.data_len = 0; } cphs_signal(E_CPHS_SET_SIM_FIELD, &read_sim_entry); simShrdPrm.atb[table_id].ntryUsdFlg = FALSE; } #ifdef FF_CPHS_REL4 UBYTE mfw_cphs_get_reg_profile(void) { TRACE_FUNCTION("mfw_cphs_get_reg_profile"); TRACE_EVENT_P1(" Get registered profile - %d", mspinfo.registered_profile); return mspinfo.registered_profile; } UBYTE mfw_cphs_get_default_profile(void) { TRACE_FUNCTION("mfw_cphs_get_default_profile"); TRACE_EVENT_P1(" Get default profile - %d", mspinfo.default_profile); return mspinfo.default_profile; } void mfw_cphs_set_reg_profile(UBYTE profile_id) { TRACE_FUNCTION("mfw_cphs_set_reg_profile"); TRACE_EVENT_P1(" Set registered profile - %d", profile_id); mspinfo.registered_profile = profile_id; } void mfw_cphs_set_default_profile(UBYTE profile_id) { TRACE_FUNCTION("mfw_cphs_set_default_profile"); TRACE_EVENT_P1(" Set default profile - %d", profile_id); mspinfo.default_profile = profile_id; } T_MFW_CPHS_MSP_INFO* mfw_cphs_get_msp(void) { TRACE_FUNCTION("mfw_cphs_get_msp"); TRACE_EVENT_P3("msp count - %d, def profile - %d, reg profile - %d ",mspinfo.count, mspinfo.default_profile, mspinfo.registered_profile); return &mspinfo; } UBYTE mfw_cphs_get_no_profile(void) { TRACE_FUNCTION("mfw_cphs_get_no_profile"); return mspinfo.count; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework MODULE: MFW_CPHS | | STATE : code ROUTINE: mfw_cphs_get_msp_info | +----------------------------------------------------------------------+ PURPOSE : query for MSP */ void mfw_cphs_get_msp_info(void) { TRACE_FUNCTION("mfw_cphs_get_msp_info()"); qAT_PlusCNUM(CMD_SRC_LCL, 0); } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework MODULE: MFW_CPHS | | STATE : code ROUTINE: check_msp_rec | +----------------------------------------------------------------------+ PURPOSE : check for valid records in sim */ int check_msp_rec(T_ACI_CNUM_MSISDN *msisdn, int i) { TRACE_FUNCTION("check_msp_rec()"); if(msisdn->vldFlag == TRUE) { strcpy(mspinfo.profile[i].alpha, msisdn->alpha); strcpy(mspinfo.profile[i].number, msisdn->number); TRACE_EVENT_P1("profile alpha %s",mspinfo.profile[i].alpha); TRACE_EVENT_P1("profile number %s",mspinfo.profile[i].number); return TRUE; } return FALSE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework MODULE: MFW_CPHS | | STATE : code ROUTINE: send_msp_signal | +----------------------------------------------------------------------+ PURPOSE : send event to MMI */ void send_msp_signal(UBYTE count) { TRACE_EVENT_P1("msp profile count %d", count); mspinfo.count = count; cphs_signal(E_CPHS_MSP_IND, &mspinfo); } #endif /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CPHS | | STATE : code ROUTINE: mfw_cphs_get_als_info | +----------------------------------------------------------------------+ PURPOSE : Returns the current active line */ //x0pleela 25 May, 2006 DR: OMAPS00070657 #ifdef FF_CPHS T_MFW mfw_cphs_get_als_info(void) { T_ACI_ALS_MOD ALSmode = ALS_MOD_NOTPRESENT; /*a0393213 compiler warnings removal - 0 changed to ALS_MOD_NOTPRESENT*/ TRACE_FUNCTION("mfw_cphs_get_als_info"); if( qAT_PercentALS( CMD_SRC_LCL, &ALSmode )!= AT_CMPL ) return ALS_MOD_NOTPRESENT; else return ALSmode; } #endif