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];
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);
}
}
/*
+--------------------------------------------------------------------+
| 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