/*-----------------------Include Files---------------------------------*/

#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 "prim.h"
#ifndef PCM_2_FFS
#include "pcm.h"
#endif


#ifndef GPRS
#include "ffs/ffs.h"
#undef GPRS  /* ffs.h anyhow defines GPRS: has to be undef ifndef GPRS */

#else /* GPRS */
#include "ffs/ffs.h"
#endif /* GPRS */

#ifndef PCM_2_FFS
#include "ffs_coat.h"
#endif

#ifdef SIM_TOOLKIT
//#include "mfw_sat.h"
#endif

#include "message.h"
#include "prim.h"
#include "aci_cmh.h"
#if defined (FAX_AND_DATA)
#include "aci_fd.h"
#endif

#ifdef GPRS
#include "gprs.h"
#endif
#include "dti_conn_mng.h"

#include "phb.h"
#include "psa.h"
#include "cmh.h"
#include "cmh_phb.h"
#include "psa.h"
#include "psa_sim.h"
#include "cus_aci.h"
#include "cmh_mm.h"
#include "cmh_sim.h"
#include "CPHS_mod.h"

/*--------------------- Constant definitions  ---------------------------*/


#define MFW_INVALID_SIM_DATA	0xFF
#define MAX_CPHS_ENTRY          4
#define MAX_PCM_MAILBOX_LEN     10


#define NO_ALLOCATED 0
#define FALSE 0
#define TRUE 1
#define LONG_NAME         26
#define SHORT_NAME        10
#define SP_NAME           17
#define NUMERIC_LENGTH    6

#ifdef TI_PS_FFS_PHB
#define PHB_MAX_LEN       MAX_PHB_NUM_LEN /* Phonebook number length + '\0' */
#else
//GW-SPR#762- 40 digit phonebook size.
#ifdef PHONEBOOK_EXTENSION
#define PHB_MAX_LEN        41 /* Phonebook number length + '\0' */
#else
#define PHB_MAX_LEN        21 /* Phonebook number length + '\0' */
#endif /* else, #ifdef PHONEBOOK_EXTENSION */
#endif /* else, #ifdef TI_PS_FFS_PHB */

/*--------------------- Types --------------------------------------*/
typedef enum              /* numbering plan identifier */
{
  CPHS_NPI_UNKNOWN,
  CPHS_NPI_ISDN      = 1,
  CPHS_NPI_DATA      = 3,
  CPHS_NPI_TELEX     = 4,
  CPHS_NPI_NATIONAL  = 8,
  CPHS_NPI_PRIVATE   = 9,
  CPHS_NPI_M_ERMES   = 10,
  CPHS_NPI_M_CTS     = 11
} T_PHB_NPI;

typedef enum            /* type of number */
{
  CPHS_TON_UNKNOWN,
  CPHS_TON_INTERNATIONAL,
  CPHS_TON_NATIONAL,
  CPHS_TON_NET_SPECIFIC,
  CPHS_TON_DED_ACCESS,
  CPHS_TON_ALPHA_NUMERIC,
  CPHS_TON_ABBREVIATED,
  CPHS_TON_EXTENDED
} T_CPHS_PHB_TON;

typedef enum              /* CPHS service */
{
  CPHS_CSP = 1,             /* customer service profile */
  CPHS_SST,                 /* service string table     */
  CPHS_MB_NUMBER,           /* mailbox numbers          */
  CHPS_NAME_SHORT,          /* operator name shortform  */
  CHPS_INFO_NUMBERS         /* information numbers      */
} T_CPHS_SERVICE;

#define CPHS_SERVICE_TABLE   2 /* size of CPHS service table            */
#define CPHS_INFO_SIZE   3 /* size of CPHS information field (6F16) */
#define CPHS_ONS_SIZE   20 /* size of operator name string (6F14) - read first 20 bytes only */
#define CPHS_ONSF_SIZE  10 /* size of operator name short form (6F18) */
#define CPHS_MIN_MBN_SIZE 14
#define CPHS_MBS_SIZE    2 /* size of voice message waiting flag (6F11) */
#define CPHS_CFF_SIZE    2 /* size of call forwarding flags (6F13)  */
#define CPHS_ALS_SIZE    1 /* size of alternate line service (6F9F) */
#define CPHS_ALSS_SIZE   1 /* size of alternate line service status (6F92) */
#define CPHS_CSP_SIZE   20 /* size of customer service profile (6F15) */
#define CPHS_MIN_INS_SIZE 5

typedef struct {

	T_CPHS_OPN       			opName;
	T_CPHS_MAILBOX_NUM_LIST		mbNum;
	T_CPHS_LINE_IND       		mbStatus;
	T_CPHS_LINE_IND       		dvStatus;
	T_CPHS_ALS_INFO   			alsStatus;
	T_CPHS_ALS_LINE				Line1_desc;
	T_CPHS_ALS_LINE				Line2_desc;
	T_CPHS_CSP           		csProfile;
	T_CPHS_INFO_NUM_LIST*  	numList;
	T_CPHS_INFO_NUM_ENTRY* 	infoEntry;
	T_CPHS_ROAMING_IND			roaming_ind;
	UBYTE                    mbnData[40]; // it should be allocated dynamically.

	UBYTE                    mbsData[CPHS_MBS_SIZE]; // it should be allocated dynamically.
	UBYTE                    dvData[CPHS_CFF_SIZE]; // it should be allocated dynamically.

//	T_CPHS_READ_SIM_ENTRY read_sim_entry;//MC

	UBYTE        			cphsStatus;
	UBYTE                    cphsPhase;
	UBYTE                    cphsServTab[CPHS_SERVICE_TABLE];
	UBYTE                    maxRec;

	T_CPHS_MAILBOX_NUM_ENTRY         MbnEntry;

	T_CPHS_MAILBOX_NUM_ENTRY    *vcEntry;
	T_CPHS_SIMOP_STATUS     simStatus;
	UBYTE                    alsData;
	UBYTE                    idxLevel;
	UBYTE                    startIdx;
	 UBYTE                    cphsUpdate ;
	ULONG                   cphsPrevRead;
	T_CPHS_CB_FUNC			InfoNumberListCB;
	T_CPHS_CB_FUNC			InfoNumberCB;
	T_CPHS_CB_FUNC			RefreshCB;
}T_CPHS_CACHED_DATA;


static T_CPHS_CACHED_DATA* cphs_data = NULL;

void Cphs_support_check (void);
UBYTE Cphs_ssc (UBYTE nr, UBYTE * serv_table);
void Cphs_update_info_cnf (SHORT errCode, UBYTE *data, UBYTE dataLen);
void Cphs_read_information(SHORT errCode, UBYTE *data, UBYTE dataLen);
void Cphs_read_csp(SHORT errCode, UBYTE *data, UBYTE dataLen);
void Cphs_read_cff(SHORT errCode, UBYTE *data, UBYTE dataLen);
void Cphs_read_mbs(SHORT errCode, UBYTE *data, UBYTE dataLen);
void Cphs_read_mbn(SHORT table_id);
void Cphs_read_onsf(SHORT errCode, UBYTE *data, UBYTE dataLen);
void Cphs_read_ons(SHORT errCode, UBYTE *data, UBYTE dataLen);
void Cphs_get_csp ();
void Cphs_get_mailbox (void);
void Cphs_read_sim_dat_cb(SHORT table_id);
BOOL Cphs_read_sim_dat(USHORT data_id, UBYTE len, UBYTE max_length);
T_CPHS_RET Cphs_set_divert_status  (T_CPHS_FLAG_STATUS line1,
                               T_CPHS_FLAG_STATUS line2,
                               T_CPHS_FLAG_STATUS fax,
                               T_CPHS_FLAG_STATUS data);
T_CPHS_RET Cphs_set_mailbox_status (T_CPHS_FLAG_STATUS line1,
                               T_CPHS_FLAG_STATUS line2,
                               T_CPHS_FLAG_STATUS fax,
                               T_CPHS_FLAG_STATUS data);
void Cphs_operator_name (void);
void Cphs_get_mailbox_status ();
void Cphs_get_divert_status () ;


void Cphs_write_eeprom_mailbox(T_CPHS_MAILBOX_NUM_ENTRY *entry);
void Cphs_read_eeprom_mailbox(void);
void Cphs_build_mbn_data(UBYTE *data, UBYTE len);
void Cphs_req_info_num_read(UBYTE rcd_num, UBYTE dataLen);
void Cphs_get_info_num (UBYTE level, UBYTE startIndex);
void Cphs_read_info_num(SHORT table_id);
void Cphs_read_first_info_num(SHORT table_id);
void Cphs_read_sim_rcd_cb (SHORT table_id);
BOOL Cphs_read_sim_rcd(USHORT data_id, UBYTE rcd_num, UBYTE len);
void Cphs_select_info_num (UBYTE index) ;
void Cphs_write_sim_dat_cb(SHORT table_id);
BOOL Cphs_write_sim_dat(USHORT data_id, UBYTE *data, UBYTE length);
void Cphs_write_sim_rcd_cb (SHORT table_id);
BOOL Cphs_write_sim_rcd(USHORT data_id, UBYTE rcd_num,
                        UBYTE *data,    UBYTE dataLen);
void Cphs_read_eeprom_als_desc();
void Cphs_write_eeprom_als_desc(T_CPHS_ALS_LINE* line);
T_CPHS_RET Cphs_write_eeprom_als(T_CPHS_ALS_INFO* info);
T_CPHS_RET Cphs_read_eeprom_als(T_CPHS_ALS_INFO* info);
void Cphs_get_als_info ();
T_CPHS_PHB_TON cvtTon(T_ACI_TOA_TON ton);
  /* initializes CPHS module, reads CPHS data fields from SIM and caches */
  /* the read data.  */
#ifdef _TESTING__
T_CPHS_INFO_NUM_LIST num_list;
T_CPHS_INFO_NUM_ENTRY num_entry;


int Info_Numbers_Callback(T_CPHS_INFO_NUM_LIST* list, T_CPHS_INFO_NUM_ENTRY* entry)
{	char debug[50];
	TRACE_FUNCTION("Info_Numbers_Callback()");

	if (list != NULL)
	{	sprintf(debug, "INFO_NUMLIST:%s, count:%d",(char*)list->entry[0].alpha.data, list->count);
		TRACE_EVENT(debug);

	}

	if (entry != NULL)
	{
		sprintf(debug, "INFO_NUM:%s",(char*)entry->alpha.data);
		TRACE_EVENT(debug);
	}
	if (list == NULL && entry == NULL)
		TRACE_EVENT("REFRESH DONE!!!!");


}

void Cphs_reading_test()
{	T_CPHS_ALS_INFO als_info;
	T_CPHS_ALS_LINE als_line;
	T_CPHS_INFO cphs_info;
	T_CPHS_CSP cphs_csp;
	T_CPHS_LINE_IND dv_ind;
	T_CPHS_MAILBOX_NUM_LIST mb_nums;
	T_CPHS_OPN op_name;
	T_CPHS_ROAMING_IND roam_ind;

	char debug[60];

	//cphs_Init(Info_Numbers_Callback);
	cphs_refresh(Info_Numbers_Callback);

	//cphs_getInfoNumbers(&num_list,1,1, Info_Numbers_Callback);
	/*cphs_getAlsInfo(&als_info);
	sprintf(debug,"line:%d, locked:%d", als_info.line, als_info.locked);
	TRACE_FUNCTION(debug);
	als_line.line = CPHS_LINE_INDEX_LINE2;
	cphs_getAlsLineDescr(&als_line);
	sprintf(debug,"line:%d, desc:%0.22s", als_line.line, als_line.description.data);
	TRACE_EVENT(debug);
	cphs_getVoiceMessageInd(&dv_ind);
	sprintf(debug, "VM result:%d, line1:%d, line2: %d", dv_ind.result, dv_ind.line1, dv_ind.line2);
	TRACE_EVENT(debug);
	cphs_getCPHSInfo(&cphs_info);
	sprintf(debug, "Phase:%d InfoNum:%d, shortname:%d, mb:%d", cphs_info.phase, cphs_info.info_num, cphs_info.opn_short, cphs_info.mailbox_num);
	TRACE_EVENT(debug);

	cphs_getCSP(&cphs_csp);
	sprintf(debug, "Result: %d, CSP:%x,%x,%x,%x,%x,%x", cphs_csp.result, cphs_csp.csp[0].services,  cphs_csp.csp[1].services,
		 cphs_csp.csp[2].services,  cphs_csp.csp[3].services,  cphs_csp.csp[4].services,  cphs_csp.csp[5].services);
	TRACE_EVENT(debug);
//#ifdef FRED
	cphs_getDivertCallInd(&dv_ind);
	sprintf(debug, "Divert result: %d, line1:%d, line2:%d", dv_ind.result, dv_ind.line1, dv_ind.line2);
	TRACE_EVENT(debug);

//#endif

	cphs_getOPN(&op_name);
	sprintf(debug, "res:%d long_name:%s, short_name%0.22s", op_name.result, op_name.long_name, op_name.short_name);
	TRACE_EVENT(debug);

	cphs_getRoamingInd(&roam_ind);
	sprintf(debug, "Roaming ind: %d", roam_ind);
	TRACE_EVENT(debug);

	cphs_getMailboxNumbers(&mb_nums);

	sprintf(debug, "MBN result: %d, count:%d, first:%0.22s",mb_nums.result, mb_nums.count, mb_nums.entries[0].number);
	TRACE_EVENT(debug);*/


}


void Cphs_writing_test()
{	T_CPHS_ALS_INFO als_info;
	T_CPHS_ALS_LINE als_line;
	T_CPHS_LINE_IND dv_ind;
	T_CPHS_ROAMING_IND roam_ind;
	char debug[50];



	cphs_Init(Info_Numbers_Callback);
	//cphs_refresh(Info_Numbers_Callback);

	als_line.line = CPHS_LINE_INDEX_LINE2;
	memcpy(als_line.description.data, (UBYTE*)"Second Line !!", 8);
	als_line.description.len = 8;
	cphs_setAlsLineDescr(als_line);

	als_info.line = CPHS_LINE_INDEX_LINE2;
	als_info.locked= CPHS_LINEFLAG_SET;
	cphs_setAlsInfo(&als_info);
	cphs_setDivertCallInd(CPHS_LINE_INDEX_LINE1, CPHS_LINEFLAG_NOT_SET);
	cphs_setDivertCallInd(CPHS_LINE_INDEX_LINE2, CPHS_LINEFLAG_SET);

	cphs_setVoiceMessageInd(CPHS_LINE_INDEX_LINE1, CPHS_LINEFLAG_NOT_SET);
	cphs_setVoiceMessageInd(CPHS_LINE_INDEX_LINE2, CPHS_LINEFLAG_SET);

	roam_ind = CPHS_ROAMING_OFF;
	cphs_setRoamingInd(&roam_ind);

	//cphs_selectInfoNumber(2, &num_entry, Info_Numbers_Callback);

}
#endif

 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_Init |
+--------------------------------------------------------------------+

*/
T_CPHS_RET cphs_Init(T_CPHS_CB_FUNC callback)
{	//check if already initilaised?
	if (cphs_data)
		return CPHS_IS_OK;
	cphs_data = (T_CPHS_CACHED_DATA*)malloc(sizeof(T_CPHS_CACHED_DATA));
	if (cphs_data)
  	{	cphs_data->cphsStatus = CPHS_NOT_PRESENT;
  		cphs_data->simStatus  = SIMOP_UNKNOWN;
  		cphs_data->cphsUpdate = FALSE;
		cphs_data->cphsPrevRead = 0;
		cphs_data->InfoNumberListCB = NULL;
		cphs_data->InfoNumberCB = NULL;
  		Cphs_support_check();
  		cphs_refresh(callback);
  		return CPHS_IS_OK;
	}
	else
		return CPHS_FAIL;
}



 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_refresh() |
+--------------------------------------------------------------------+


*/

 /* reads CPHS data fields from SIM and updates the cached CPHS data    */
T_CPHS_RET cphs_refresh(T_CPHS_CB_FUNC callback)
 {	T_CPHS_RET res;

 	if (cphs_data EQ NULL)
 	{	TRACE_EVENT("CPHS not initialised");
		return CPHS_NOT_INIT;
 	}
 	//get call divert indicator
	Cphs_get_divert_status ();
 	cphs_data->RefreshCB = callback; //set call back function
 	//get mailbox numbers
	/*Cphs_get_mailbox ();
 	Cphs_operator_name ();
	//get voice message indicator
	Cphs_read_eeprom_als_desc();
	//get als line description
	Cphs_get_mailbox_status ();
	//get CSP
	Cphs_get_csp ();*/
 }


 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_Exit() |
+--------------------------------------------------------------------+


*/
/* de-initializes CPHS module                                          */
T_CPHS_RET cphs_Exit()
{	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

	free(cphs_data);

	return CPHS_IS_OK;
}

 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getOPN  |
+--------------------------------------------------------------------+


*/
  /* reads from SIM the operator long name and if available the short    */
  /* name, too  */
T_CPHS_RET cphs_getOPN            ( T_CPHS_OPN *opn )
{	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
  	if (opn EQ NULL)
  		return CPHS_FAIL;
	memcpy(opn, &cphs_data->opName, sizeof(T_CPHS_OPN));
	return CPHS_IS_OK;
}
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getRoamingInd |
+--------------------------------------------------------------------+


*/

/* checks if roaming is active                                         */
T_CPHS_RET cphs_getRoamingInd     ( T_CPHS_ROAMING_IND *indicator )
{
#ifndef NEPTUNE_BOARD
/*
  T_ACI_COPS_MOD  mode;
  T_ACI_COPS_FRMT  format;
  CHAR  oper[30];
  T_OPER_NTRY* plmn_entry;
  SHORT mccBuf, mncBuf;
  char debug[50];
  UBYTE numeric[8];
  char ** end;
  memset(oper, 0, 30);
*/
#else
	T_ACI_COPS_MOD  mode;
  	T_ACI_COPS_FRMT  format;
    CHAR  oper[30];
    T_OPER_NTRY* plmn_entry;
    SHORT mccBuf, mncBuf;
    char debug[50];
    UBYTE numeric[8];
    char ** end;
    memset(oper, 0, 30);
#endif

  if (cphs_data EQ NULL)
    return CPHS_NOT_INIT;
  if (indicator EQ NULL)
    return CPHS_FAIL;
#ifndef NEPTUNE_BOARD
  *indicator = cphs_data->roaming_ind;
#else
	memcpy(indicator, &cphs_data->roaming_ind, sizeof(T_CPHS_ROAMING_IND));
#endif
/*
		qAT_PlusCOPS (CMD_SRC_NONE,&mode,&format,oper );
		//get current MCC
		if (format == COPS_FRMT_Long OR format == COPS_FRMT_Short)
		{	sAT_PlusCOPSE(oper, format, NULL, NULL, numeric);
		//	plmn_entry = cmhMM_FindName( oper, format );
			numeric[3] = 0;//terminate string before MNC
			plmn_entry->mcc = strtol((char*)numeric,end,16 );
		}

		if (format == COPS_FRMT_Numeric)
		{	//plmn_entry = cmhMM_FindNumeric( oper );
			oper[3] = 0;
			plmn_entry->mcc = strtol((char*)oper, end, 16);
		}
		//get "Home MCC"
		cmhSIM_GetHomePLMN ( &mccBuf, &mncBuf );
		//currently qAT_PlusCOPS is not returning the correct format
		//cmhMM_FindName/Numeric rely on PCM which does not work
		sprintf(debug, "Home MCC %d, current MCC %d COPS fmt:%d", plmn_entry->mcc, mccBuf, format);
		TRACE_EVENT(debug);
		if (plmn_entry->mcc == mccBuf)
			*indicator = CPHS_ROAMING_OFF;
		else
			*indicator = CPHS_ROAMING_ON;
*/

  return CPHS_IS_OK;
}
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getVoiceMessageInd |
+--------------------------------------------------------------------+


*/

 /* reads from SIM if voice mails are waiting for the available lines   */
  /* (line1, line2, fax, data)                                           */
T_CPHS_RET cphs_getVoiceMessageInd( T_CPHS_LINE_IND *indicator )
{	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
  	if (indicator EQ NULL)
  		return CPHS_FAIL;
	memcpy(indicator, &cphs_data->mbStatus, sizeof(T_CPHS_LINE_IND));
	return CPHS_IS_OK;
}
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_setVoiceMessageInd |
+--------------------------------------------------------------------+


*/
/* sets on SIM the voice mail waiting flag for the given lines in the  */
  /* parameter line_mask. The bitmask will be created by oring the lines.*/
  /* The bits for the lines are defined in T_CPHS_LINE_INDEX.            */
T_CPHS_RET cphs_setVoiceMessageInd( UBYTE              line_mask,
                                    T_CPHS_FLAG_STATUS flag )
{
	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

	if (CPHS_LINE_INDEX_LINE1 & line_mask)
	{	cphs_data->mbStatus.line1 = flag;
		TRACE_EVENT("Setting Line 1 VM");
		Cphs_set_mailbox_status(flag,CPHS_FLAG_NOT_PRESENT ,CPHS_FLAG_NOT_PRESENT,CPHS_FLAG_NOT_PRESENT);
	}

	if (CPHS_LINE_INDEX_LINE2 & line_mask)
	{	TRACE_EVENT("SEtting line 2 VM");
		cphs_data->mbStatus.line2 = flag;
		Cphs_set_mailbox_status(CPHS_FLAG_NOT_PRESENT, flag,CPHS_FLAG_NOT_PRESENT,CPHS_FLAG_NOT_PRESENT);
	}
	if (CPHS_LINE_INDEX_FAX & line_mask)
	{	cphs_data->mbStatus.fax = flag;
		Cphs_set_mailbox_status(CPHS_FLAG_NOT_PRESENT, CPHS_FLAG_NOT_PRESENT,flag,CPHS_FLAG_NOT_PRESENT);
	}
	if (CPHS_LINE_INDEX_DATA & line_mask)
	{	cphs_data->mbStatus.data = flag;
		Cphs_set_mailbox_status(CPHS_FLAG_NOT_PRESENT, CPHS_FLAG_NOT_PRESENT,CPHS_FLAG_NOT_PRESENT,flag);
	}



	return CPHS_EXEC;
}
  /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getDivertCallInd   |
+--------------------------------------------------------------------+
*/


  /* reads from SIMif calls shall be diverted for the available lines    */
  /* (line1, line2, fax, data) */
T_CPHS_RET cphs_getDivertCallInd  (T_CPHS_LINE_IND *indicator )
{
	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
	if (ind EQ NULL)
		return CPHS_FAIL;
	memcpy(indicator, &cphs_data->dvStatus, sizeof(T_CPHS_LINE_IND));
	return CPHS_IS_OK;
}
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_setDivertCallInd |
+--------------------------------------------------------------------+
*/
  /* sets on SIM the divert call flag for the given lines in the         */
  /* parameter line_mask. The bitmask will be created by oring the lines.*/
  /* The bits for the lines are defined in T_CPHS_LINE_INDEX.            */
T_CPHS_RET cphs_setDivertCallInd  ( UBYTE              line_mask,
                                    T_CPHS_FLAG_STATUS flag )
{
	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

	if (CPHS_LINE_INDEX_LINE1 & line_mask)
	{	cphs_data->dvStatus.line1 = flag;
		TRACE_EVENT("Setting line 1 divert");
		Cphs_set_divert_status(flag,CPHS_FLAG_NOT_PRESENT ,CPHS_FLAG_NOT_PRESENT,CPHS_FLAG_NOT_PRESENT);
	}

	if (CPHS_LINE_INDEX_LINE2 & line_mask)
	{	cphs_data->dvStatus.line2 = flag;
		TRACE_EVENT("Setting line 2 divert");
		Cphs_set_divert_status(CPHS_FLAG_NOT_PRESENT, flag,CPHS_FLAG_NOT_PRESENT,CPHS_FLAG_NOT_PRESENT);
	}
	if (CPHS_LINE_INDEX_FAX & line_mask)
	{	cphs_data->dvStatus.fax = flag;
		Cphs_set_divert_status(CPHS_FLAG_NOT_PRESENT, CPHS_FLAG_NOT_PRESENT,flag,CPHS_FLAG_NOT_PRESENT);
	}
	if (CPHS_LINE_INDEX_DATA & line_mask)
	{	cphs_data->dvStatus.data = flag;
		Cphs_set_divert_status(CPHS_FLAG_NOT_PRESENT, CPHS_FLAG_NOT_PRESENT,CPHS_FLAG_NOT_PRESENT,flag);
	}

	return CPHS_EXEC;

}

 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getAlsInfo |
+--------------------------------------------------------------------+
*/
  /* reads from SIM the information of alternate line service            */
  /* ( selected line, alternate line service locked/unlocked)            */
T_CPHS_RET cphs_getAlsInfo        ( T_CPHS_ALS_INFO *info )
{
	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
	if (info EQ NULL)
		return CPHS_FAIL;

	//memcpy(info, &cphs_data->alsStatus, sizeof( T_CPHS_ALS_INFO));
	Cphs_read_eeprom_als(info);
	return CPHS_IS_OK;

}
   /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_setAlsInfo|
+--------------------------------------------------------------------+
*/
  /* sets on SIM the informtion of alternate line service / selects the  */
  /* active line */
T_CPHS_RET cphs_setAlsInfo        ( T_CPHS_ALS_INFO *info )
 {	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
  	if (info EQ NULL)
  		return CPHS_FAIL;
	//memcpy(&cphs_data->alsStatus, info, sizeof(T_CPHS_ALS_INFO));
 	return Cphs_write_eeprom_als(info);
 	//return CPHS_EXEC;
 }
   /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getAlsLineDescr |
+--------------------------------------------------------------------+
*/
 /* reads the (alpha)numeric description for the given line             */
T_CPHS_RET cphs_getAlsLineDescr   ( T_CPHS_ALS_LINE* line )
 {	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
	if (line EQ NULL)
		return CPHS_FAIL;
	Cphs_read_eeprom_als_desc();
 	if (line->line EQ CPHS_LINE_INDEX_LINE1)
	{	memcpy(line,&cphs_data->Line1_desc,  sizeof(T_CPHS_ALS_LINE));
 		return CPHS_IS_OK;
 	}

 	if (line->line EQ CPHS_LINE_INDEX_LINE2)
	{	memcpy( line, &cphs_data->Line2_desc,sizeof(T_CPHS_ALS_LINE));
 		return CPHS_IS_OK;
 	}

	return CPHS_FAIL;
 }
  /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE :cphs_setAlsLineDescr |
+--------------------------------------------------------------------+
*/
 /* sets a (alpha)numeric description for the given line                */
T_CPHS_RET cphs_setAlsLineDescr   ( T_CPHS_ALS_LINE line )

 {	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

 	if (line.line EQ CPHS_LINE_INDEX_LINE1)
	{	memcpy(&cphs_data->Line1_desc,&line,  sizeof(T_CPHS_ALS_LINE));
 		Cphs_write_eeprom_als_desc(&cphs_data->Line1_desc);
 		return CPHS_IS_OK;
 	}

 	if (line.line EQ CPHS_LINE_INDEX_LINE2)
	{	memcpy(&cphs_data->Line2_desc, &line, sizeof(T_CPHS_ALS_LINE));
 		Cphs_write_eeprom_als_desc(&cphs_data->Line2_desc);
 		return CPHS_IS_OK;
 	}

	return CPHS_FAIL;
 }
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_setRoamingInd |
+--------------------------------------------------------------------+

*/
T_CPHS_RET cphs_setRoamingInd ( T_CPHS_ROAMING_IND* indicator )
{	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

	if (*indicator EQ CPHS_ROAMING_OFF OR *indicator EQ CPHS_ROAMING_ON)
	{	cphs_data->roaming_ind  = *indicator;
		return CPHS_IS_OK;
	}
	else
		return CPHS_FAIL;
}
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_checkEmergencyCall |
+--------------------------------------------------------------------+
*/

/* check if the current call number(ASCII encoded) is an emergency number supported     */
/* by CPHS.                                                              */
T_CPHS_RET cphs_checkEmergencyCall( char* num )
{	char** end;


	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

	if (num EQ NULL)
		return CPHS_FAIL;

	if (strtol(num, end, 10)EQ CPHS_EMERGENCY_NUM_112 OR
		strtol(num, end, 10)EQ CPHS_EMERGENCY_NUM_999)
		return CPHS_IS_OK;
	else
		return CPHS_FAIL;
}

 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getCPHSInfo  |
+--------------------------------------------------------------------+
*/
 /* reads from SIM the phase of the SIM and which optional datafields   */
  /* are present in the SIM                                              */
  /* (operator name shortform, mailbox numbers, service string table,    */
  /*  information numbers)                                               */
T_CPHS_RET cphs_getCPHSInfo       ( T_CPHS_INFO *info )
 {	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;

	if (info !=NULL)
  {
    info->phase = cphs_data->cphsPhase;
    info->csp   = Cphs_ssc(CPHS_CSP,          cphs_data->cphsServTab);
    info->mailbox_num = Cphs_ssc(CPHS_MB_NUMBER,    cphs_data->cphsServTab);

    if (cphs_data->cphsPhase EQ 1) /* phase 1 only */
      info->sst = Cphs_ssc(CPHS_SST,          cphs_data->cphsServTab);
    else                /* not support */
      info->sst = NO_ALLOCATED;

    if (cphs_data->cphsPhase EQ 2) /* phase 2 only */
    {
      info->opn_short  = Cphs_ssc(CHPS_NAME_SHORT,   cphs_data->cphsServTab);
      info->info_num  = Cphs_ssc(CHPS_INFO_NUMBERS, cphs_data->cphsServTab);
    }
    else                /* not support */
    {
      info->opn_short  = NO_ALLOCATED;
      info->info_num  = NO_ALLOCATED;
    }
    return CPHS_IS_OK;
  }
  return CPHS_FAIL;

 }

 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getCSP |
+--------------------------------------------------------------------+

*/
 /* reads all entries of the customer service profile and fills         */
T_CPHS_RET cphs_getCSP            ( T_CPHS_CSP *csp )
 {	if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
	if (csp EQ NULL)
		return CPHS_FAIL;

	memcpy(csp, &cphs_data->csProfile, sizeof(T_CPHS_CSP));
	return CPHS_IS_OK;
 }

 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getMailboxNumbers |
+--------------------------------------------------------------------+
*/
 /* reads all mailbox numbers from the SIM fills all mailbox number     */
  /* entries in the mailbox number list                                  */
T_CPHS_RET cphs_getMailboxNumbers ( T_CPHS_MAILBOX_NUM_LIST *nums )
 {if (cphs_data EQ NULL)
		return CPHS_NOT_INIT;
	if (nums EQ NULL)
		return CPHS_FAIL;

	memcpy(nums, &cphs_data->mbNum, sizeof(T_CPHS_CSP));
	return CPHS_IS_OK;
 }
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_getInfoNumbers|
+--------------------------------------------------------------------+

*/


 /* reads all information numbers from the SIM fills all information    */
  /* numbers into the array of pointers to information number lists down to the level specified  */
  //MC-Not sure about the format of this as current mfw_cphs code returns an information number list
  //with only 4 entries
T_CPHS_RET cphs_getInfoNumbers    ( T_CPHS_INFO_NUM_LIST *nums, UBYTE level, UBYTE start_index, T_CPHS_CB_FUNC callback)
{		cphs_data->InfoNumberListCB = callback;
 		cphs_data->numList=nums;
		Cphs_get_info_num(level, start_index);
 }
 /*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : cphs_selectInfoNumber |
+--------------------------------------------------------------------+

  PURPOSE : reads the information number entry given by level and index from
   the SIM

*/
T_CPHS_RET cphs_selectInfoNumber  ( USHORT                 index,
                                    T_CPHS_INFO_NUM_ENTRY *num, T_CPHS_CB_FUNC callback)
{	cphs_data->InfoNumberCB = callback;
 	cphs_data->infoEntry= num;
	Cphs_select_info_num(index);
	//num = &cphs_data->infoEntry;

}




/*
+--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| 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, CPHS_INFO_SIZE))
  {
    /* Read failed */
    cphs_data->cphsStatus = CPHS_NOT_PRESENT;

  }
}



 /*
  +--------------------------------------------------------------------+
|         MODULE  : CPHS standalone module           |
| STATE   : code                        ROUTINE : Cphs_operator_name |
+--------------------------------------------------------------------+

  PURPOSE : Request the network operator name

*/

void Cphs_operator_name (void)
{
  TRACE_FUNCTION ("Cphs_operator_name()");

  /* Check CPHS support status */
  if (cphs_data->cphsStatus EQ CPHS_NOT_PRESENT)
    return;

  /* Read operator name sring */
  if (!Cphs_read_sim_dat(SIM_CPHS_ONSTR, NOT_PRESENT_8BIT, CPHS_ONS_SIZE))
  {
    /* Read operator name sring failed */
    cphs_data->opName.long_name.len = 0;

    /* Read operator name shortform */
    if ((cphs_data->cphsPhase NEQ 2)                                                          OR
        (Cphs_ssc(CHPS_NAME_SHORT,   cphs_data->cphsServTab) NEQ ALLOCATED_AND_ACTIVATED) OR
        !Cphs_read_sim_dat(SIM_CPHS_ONSHF, NOT_PRESENT_8BIT, CPHS_ONSF_SIZE)                  )
    {
      /* Read operator name shortform failed.
           */
      cphs_data->opName.short_name.len = 0;
      cphs_data->opName.result = SIMOP_READ_ERR;
    }
  }

}

  /*
+-------------------------------------------------------------------------+
|         MODULE  : CPHS standalone module                |
| STATE   : code                        ROUTINE : Cphs_get_mailbox_status |
+-------------------------------------------------------------------------+

  PURPOSE : get the voice message waiting flag

*/

void Cphs_get_mailbox_status ()
{
  TRACE_FUNCTION ("Cphs_get_mailbox_status()");

  /* Check CPHS support status. */
  if (cphs_data->cphsStatus EQ CPHS_NOT_PRESENT)
    return ;

  /* 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, CPHS_MBS_SIZE))
  {
    cphs_data->mbStatus.result = SIMOP_READ_ERR;
    TRACE_EVENT("Reading mailbox status failed");
  }
}

/*
+------------------------------------------------------------------------+
|         MODULE  : CPHS standalone module               |
| STATE   : code                        ROUTINE : Cphs_get_divert_status |
+------------------------------------------------------------------------+

  PURPOSE : Request the call forwarding flags

*/

void Cphs_get_divert_status ()
{
  TRACE_FUNCTION ("Cphs_get_divert_status()");

  /* Check CPHS support status. */
  if (cphs_data->cphsStatus EQ CPHS_NOT_PRESENT)
    return;

  /* Read call forwarding flags.
     When this reading failed, send event with "read error" parameter to MMI */
  if (!Cphs_read_sim_dat(SIM_CPHS_CFF, NOT_PRESENT_8BIT, CPHS_CFF_SIZE))
  {
    cphs_data->dvStatus.result = SIMOP_READ_ERR;

  }

}

/*
+---------------------------------------------------------------------+
|         MODULE  : CPHS standalone module            |
| 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.

*/
//ATM, cannot get als lock status from SIM
/*void Cphs_get_als_info ()
{
  TRACE_EVENT ("Cphs_get_als_info()");

    Cphs_read_eeprom_als();

}*/

/*
+---------------------------------------------------------------------+
|         MODULE  : CPHS standalone module            |
| STATE   : code                        ROUTINE : Cphs_get_csp        |
+---------------------------------------------------------------------+

  PURPOSE : Request the customer service profile

*/

void Cphs_get_csp ()
{
  UBYTE res;

  TRACE_FUNCTION ("Cphs_get_csp()");

  /* Check CPHS support status. */
  if (cphs_data->cphsStatus EQ CPHS_NOT_PRESENT)
    return ;

  /* check CPHS service table */
  res = Cphs_ssc(CPHS_CSP, cphs_data->cphsServTab);
  if ( res NEQ ALLOCATED_AND_ACTIVATED)
    return;

  /* 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, CPHS_CSP_SIZE))
  {
    cphs_data->csProfile.result = SIMOP_READ_ERR;
    memset(cphs_data->csProfile.csp, 0, sizeof(cphs_data->csProfile.csp));
  }
}
/*
+---------------------------------------------------------------------+
|         MODULE  : CPHS standalone module            |
| STATE   : code                        ROUTINE : Cphs_get_mailbox       |
+---------------------------------------------------------------------+

  PURPOSE : Request the customer service profile

*/
void Cphs_get_mailbox (void)
{
  TRACE_FUNCTION ("Cphs_get_mailbox()");

  cphs_data->mbNum.count = 0;

  /* Check CPHS support status.
     When CPHS is not support, read mailbox numbers from EEPROM */
  if (cphs_data->cphsStatus EQ CPHS_NOT_PRESENT)
  {
    Cphs_read_eeprom_mailbox();
    return;
  }

  /* Check CPHS service table.
     When CPHS is not support, read mailbox numbers from EEPROM */
  if (Cphs_ssc(CPHS_MB_NUMBER, cphs_data->cphsServTab) NEQ ALLOCATED_AND_ACTIVATED)
  {
  	TRACE_EVENT("CPHS doesn't support mailbox");
    Cphs_read_eeprom_mailbox();
    return;
  }

  /* Read mailbox numbers from SIM.
     When this reading failed, read mailbox numbers from EEPROM */
     //cphs_data->simStatus = SIMOP_UNKNOWN;
  if (!Cphs_read_sim_rcd(SIM_CPHS_MBXN, 1, 0)) /* read the first record */
  {	TRACE_EVENT("Mailbox Sim read failed");
    Cphs_read_eeprom_mailbox();
  }
}

/*
+----------------------------------------------------------------------+
|          MODULE: CPHS standalone module               |
| 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;
}

/*
+------------------------------------------------------------------------+
| MODULE  : CPHS standalone module               						|
| STATE   : code                        ROUTINE : Cphs_set_mailbox_status|
+------------------------------------------------------------------------+

  PURPOSE : Set the mailbox status on each line

*/

 T_CPHS_RET Cphs_set_mailbox_status (T_CPHS_FLAG_STATUS line1,
                               T_CPHS_FLAG_STATUS line2,
                               T_CPHS_FLAG_STATUS fax,
                               T_CPHS_FLAG_STATUS data)
{
  UBYTE result;
  char debug[50];

  TRACE_FUNCTION ("Cphs_set_mailbox_status()");

  /* Check CPHS support status. */
 // if (cphs_data->cphsStatus EQ CPHS_NOT_PRESENT)
 //   return CPHS_FAIL;
  sprintf(debug, "Original mailbox status: %x%x",cphs_data->mbsData[0],cphs_data->mbsData[1]);
  TRACE_EVENT(debug);
  /* Write status in buffer */
  if (line1 EQ CPHS_LINEFLAG_SET   OR
      line1 ==CPHS_LINEFLAG_NOT_SET  )
  {             			/* low Nibble */
  	cphs_data->mbsData[0]&=0xF0; //get rid of low nibble
  	cphs_data->mbsData[0] += (line1&0x0F);
  	}
 /* else
    cphs_data->mbsData[0] |= 0x0F;*/

  if (line2 EQ CPHS_LINEFLAG_SET   OR
      line2 EQ CPHS_LINEFLAG_NOT_SET  )
  {	cphs_data->mbsData[0]&=0x0F; //get rid of high nibble
    cphs_data->mbsData[0] += (line2 << 4)&0xF0;    /* high Nibble */
  }
/*  else
    cphs_data->mbsData[0] = 0xF0 | cphs_data->mbsData[0];*/

  if (fax EQ CPHS_LINEFLAG_SET   OR
      fax EQ CPHS_LINEFLAG_NOT_SET  )
  {cphs_data->mbsData[1]&=0xF0; //get rid of low nibble
    cphs_data->mbsData[1] += fax&0x0F;              /* low Nibble */
  }
/*  else
    cphs_data->mbsData[1] |= 0x0F;*/

  if (data EQ CPHS_LINEFLAG_SET   OR
      data EQ CPHS_LINEFLAG_NOT_SET  )
  {	cphs_data->mbsData[1]&=0x0F; //get rid of high nibble
    cphs_data->mbsData[1] += (data << 4)&0xF0;     /* high Nibble */
  }
/*  else
    cphs_data->mbsData[1] = 0xF0 | cphs_data->mbsData[1];*/

	sprintf(debug, "MBS Data:%x%x", cphs_data->mbsData[0], cphs_data->mbsData[1]);
	TRACE_EVENT(debug);

  /* Read voice message waiting flag to determine the size */
  cphs_data->simStatus = SIMOP_WRITE_OK;
  if (!Cphs_read_sim_dat(SIM_CPHS_VMW, NOT_PRESENT_8BIT, CPHS_MBS_SIZE))
  //if (!Cphs_write_sim_dat(SIM_CPHS_VMW, cphs_data->mbsData, CPHS_MBS_SIZE))
  { TRACE_EVENT("Mailbox status SIM write failed");
    return  CPHS_SIM_WRITE_ERROR;
  }
}

/*
+------------------------------------------------------------------------+
| MODULE  : CPHS standalone module               						|
| STATE   : code                        ROUTINE : Cphs_set_divert_status|
+------------------------------------------------------------------------+

  PURPOSE : Set the divert status on each line

*/

T_CPHS_RET Cphs_set_divert_status  (T_CPHS_FLAG_STATUS line1,
                               T_CPHS_FLAG_STATUS line2,
                               T_CPHS_FLAG_STATUS fax,
                               T_CPHS_FLAG_STATUS data)
{
  UBYTE result;
  char debug[50];

  TRACE_FUNCTION ("Cphs_set_divert_status()");

  /* Check CPHS support status. */
 // if (cphs_data->cphsStatus EQ CPHS_NOT_PRESENT)
  //  return cphs_data->cphsStatus;
sprintf(debug, "Original divert status: %x%x",cphs_data->dvData[0],cphs_data->dvData[1]);
  TRACE_EVENT(debug);
  /* Write status in buffer */
  if (line1 EQ CPHS_LINEFLAG_SET  OR
      line1 EQ CPHS_LINEFLAG_NOT_SET  )
  { cphs_data->dvData[0] &= 0xF0;			//zero low nibble
  	cphs_data->dvData[0] += line1&0x0F;            /* low Nibble */
  	}
  /*else
    cphs_data->dvData[0] |= 0x0F;*/

  if (line2 EQ CPHS_LINEFLAG_SET   OR
      line2 EQ CPHS_LINEFLAG_NOT_SET  )
  {cphs_data->dvData[0] &= 0x0F;			//zero high nibble
    cphs_data->dvData[0] += (line2 << 4)&0xF0;    /* high Nibble */
  }
  /*else
    cphs_data->dvData[0] = 0xF0 | cphs_data->dvData[0];*/

  if (fax EQ CPHS_LINEFLAG_SET   OR
      fax EQ CPHS_LINEFLAG_NOT_SET  )
  {  cphs_data->dvData[0] &= 0xF0;			//zero low nibble
    cphs_data->dvData[1] += fax&0x0F;              /* low Nibble */
  	}
 /* else
    cphs_data->dvData[1] |= 0x0F;*/

  if (data EQ CPHS_LINEFLAG_SET   OR
      data EQ CPHS_LINEFLAG_NOT_SET  )
  {	cphs_data->dvData[1] &= 0x0F;			//zero high nibble
    cphs_data->dvData[1] += (data << 4)&0xF0;     /* high Nibble */
  }
  /*else
    cphs_data->dvData[1] = 0xF0 | cphs_data->dvData[1];*/
	sprintf(debug, "Divert Data:%x%x", cphs_data->dvData[0], cphs_data->dvData[1]);
	TRACE_EVENT(debug);
  /* Read call forwarding flag to determine the size */
  cphs_data->simStatus = SIMOP_WRITE_OK;
  if (!Cphs_read_sim_dat(SIM_CPHS_CFF, NOT_PRESENT_8BIT, CPHS_CFF_SIZE))
  {	TRACE_EVENT("Mailbox SIM write failed");
    return SIMOP_WRITE_ERR;
    //cphs_sign_exec(E_CPHS_SET_DV_STAT, &result);
  }
/* PATCH VO 22.01.01 end */
  return cphs_data->cphsStatus;
}

/*CPHS_RET cphs_set_als_status (T_CPHS_ALS_INFO status)
{
  UBYTE result;
  //T_MFW_SIM_PIN_STATUS pinStatus;

  //TRACE_EVENT ("cphs_set_als_status()");

  /* check PIN 2 requirement */
  /*pinStatus.type = MFW_SIM_PIN2;
  sim_pin_status(&pinStatus);
  if (pinStatus.set 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_sign_exec(E_CPHS_SET_ALS_STATUS, &result);
    return CPHS_ERR;
  }*/

 /* cphs_data->alsData = (UBYTE)status.locked;*/

    /* write lock status in EEPROM */
    //MC cphs_write_eeprom_alss(&result);
    //cphs_sign_exec(E_CPHS_SET_LINE, &result);
//  }
/*  return CPHS_IS_OK;
}*/

/*
+----------------------------------------------------------------------+
| MODULE: CPHS standalone module               							|
| 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()");

  res = cmhSIM_ReadTranspEF ( CMD_SRC_NONE,
                              AT_CMD_NONE,
                              data_id,
                              0,
                              max_length,
                              NULL,
                              Cphs_read_sim_dat_cb);
  if (res NEQ AT_EXCT)
    return FALSE;

  return TRUE;
}

/*
+----------------------------------------------------------------------+
| MODULE: CPHS standalone module               							|
| 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;


  switch (simShrdPrm.atb[table_id].reqDataFld)
  {
    case SIM_CPHS_CINF:	/* CPHS information */
      if (!cphs_data->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);
      Cphs_get_mailbox_status();//get next item
      break;

    case SIM_CPHS_VMW:	/* voice message waiting flag */

      if (cphs_data->simStatus EQ 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.                     */
        cphs_data->simStatus = 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, cphs_data->mbsData, dataLen))
          {
            cphs_data->mbStatus.result    = SIMOP_WRITE_ERR;

            cphs_data->mbStatus.line1 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->mbStatus.line2 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->mbStatus.fax = CPHS_FLAG_NOT_PRESENT;
            cphs_data->mbStatus.data = CPHS_FLAG_NOT_PRESENT;
          }
        }
        else
        {
          cphs_data->mbStatus.result = SIMOP_WRITE_ERR;
          //cphs_sign_exec(E_CPHS_SET_VC_STAT, &result);
          cphs_data->mbStatus.line1 = CPHS_FLAG_NOT_PRESENT;
		  cphs_data->mbStatus.line2 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->mbStatus.fax = CPHS_FLAG_NOT_PRESENT;
            cphs_data->mbStatus.data = CPHS_FLAG_NOT_PRESENT;
        }
      }
      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);
      	Cphs_get_csp();
      }
      break;

    case SIM_CPHS_CFF:	/* call forwarding flag */
/* PATCH VO 22.01.01 */
      if (cphs_data->simStatus EQ 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.                     */
        cphs_data->simStatus = 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 */
         if (!Cphs_write_sim_dat(SIM_CPHS_CFF, cphs_data->dvData, dataLen))
          { TRACE_EVENT("Divert write failed");
            cphs_data->dvStatus.result    = SIMOP_WRITE_ERR;
             cphs_data->dvStatus.line1 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->dvStatus.line2 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->dvStatus.fax = CPHS_FLAG_NOT_PRESENT;
            cphs_data->dvStatus.data = CPHS_FLAG_NOT_PRESENT;
          }
        }
        else
        {TRACE_EVENT("Sim error while writing");
          cphs_data->dvStatus.result = SIMOP_WRITE_ERR;
            cphs_data->dvStatus.line1 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->dvStatus.line2 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->dvStatus.fax = CPHS_FLAG_NOT_PRESENT;
            cphs_data->dvStatus.data = CPHS_FLAG_NOT_PRESENT;
        }
      }
      else
/* PATCH VO 22.01.01 end */
      	{Cphs_get_mailbox();
      		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);
      //All CPHS data fields have now been read
      //so call callback function to alert client layer

      break;

    default:
      break;
  }
  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
}

/*
+----------------------------------------------------------------------+
| MODULE: CPHS standalone module               							|
| 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()");

  if (rcd_num EQ 1)
      dataLen  = UCHAR_MAX;
    else
      dataLen  = len;

  res = cmhSIM_ReadRecordEF ( CMD_SRC_NONE,
                              AT_CMD_NONE,
                              data_id,
                              rcd_num,
                              dataLen,
                              NULL,
                              Cphs_read_sim_rcd_cb);

  if (res NEQ AT_EXCT)
    return FALSE;

  return TRUE;
}

/*
+----------------------------------------------------------------------+
| MODULE: CPHS standalone module               							|
| 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;
  char debug[25];
sprintf(debug, "SIM Error code!!!%d", simShrdPrm.atb[table_id].errCode);

  TRACE_FUNCTION ("Cphs_read_sim_rcd_cb()");
  TRACE_EVENT(debug);

  switch (simShrdPrm.atb[table_id].reqDataFld)
  {
    case SIM_CPHS_MBXN: /* mailbox numbers */
      if (cphs_data->simStatus EQ 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.                                 */
        cphs_data->simStatus = 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)) */
          Cphs_build_mbn_data(cphs_data->mbnData, dataLen);
          if (!Cphs_write_sim_rcd(SIM_CPHS_MBXN, cphs_data->vcEntry->index,
                                cphs_data->mbnData, dataLen))
            Cphs_write_eeprom_mailbox(cphs_data->vcEntry);
        }
        else
          Cphs_write_eeprom_mailbox(cphs_data->vcEntry);
      }
      else
        Cphs_read_mbn(table_id);

      break;

    case SIM_CPHS_INFN: /* information numbers */
      if (simShrdPrm.atb[table_id].recNr EQ 1)
      {

        if ((cphs_data->startIdx EQ 1) AND (cphs_data->simStatus EQ SIMOP_READ_OK))
          Cphs_read_info_num(table_id);
        else

          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)
      {

        if ((cphs_data->startIdx EQ 1) AND (cphs_data->simStatus EQ SIMOP_READ_OK))
          Cphs_read_info_num(table_id);
        else
        Cphs_read_first_info_num(table_id);
      }
      else
        Cphs_read_info_num(table_id);
      break;

    default:
      break;
  }
  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
}

/*
+----------------------------------------------------------------------+
| MODULE: CPHS standalone module   							            |
| 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()");

  res = cmhSIM_WriteRecordEF (CMD_SRC_NONE,
                              AT_CMD_NONE,
                              data_id,
                              rcd_num,
                              dataLen,
                              data,
                              Cphs_write_sim_rcd_cb);

  if (res NEQ AT_EXCT)
    return FALSE;

  return TRUE;
}

/*
+----------------------------------------------------------------------+
| MODULE: CPHS standalone module               |
| 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;
char debug[30];
  TRACE_FUNCTION ("Cphs_write_sim_rcd_cb()");
	sprintf(debug, "SIM Error code!!!%d", simShrdPrm.atb[table_id].errCode);
  TRACE_EVENT(debug);
  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
      {
        cphs_data->mbNum.result = SIMOP_WRITE_OK;
        //cphs_sign_exec(E_CPHS_SET_VC_NUM, &result);
      }
      else
      {
        Cphs_write_eeprom_mailbox(cphs_data->vcEntry);
      }
      break;

    default:
      break;
  }
  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
}

/*
+--------------------------------------------------------------------------+
|         MODULE  : CPHS standalone module                 |
| 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*        pData;         /* points to data buffer    */
  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 (cphs_data->simStatus EQ SIMOP_READ_OK) /* Read entry of information numbers */
    {
      cphs_data->simStatus = SIMOP_UNKNOWN;
      cphs_data->infoEntry->result = SIMOP_READ_ERR;
      if (cphs_data->InfoNumberCB != NULL)
      	(cphs_data->InfoNumberCB)(NULL, cphs_data->infoEntry);

    }
    else
    {// if we are here then its possible the read of 7F20 6F19 failed.
     // so we must try reading 7F10 EA01 instead.

     if (cphs_data->cphsPrevRead EQ SIM_CPHS_INFN)
     {
      if (!Cphs_read_sim_rcd(SIM_CPHS_INFN2, 1, 0))
      {
        cphs_data->infoEntry->result = SIMOP_READ_ERR;
        if (cphs_data->InfoNumberCB != NULL)
        	(cphs_data->InfoNumberCB)(NULL, cphs_data->infoEntry);
      }
      else
      {
        cphs_data->cphsPrevRead = SIM_CPHS_INFN2;
      }
     }
    else
    { if (cphs_data->InfoNumberListCB != NULL)
     	(cphs_data->InfoNumberListCB)(cphs_data->numList, NULL);
    }
    }
  }
  else
  {
    cphs_data->maxRec = simShrdPrm.atb[table_id].recMax;
    dataLen = simShrdPrm.atb[table_id].dataLen;

    if (cphs_data->simStatus EQ SIMOP_READ_OK) /* Read entry of information numbers */
    {
      /* VO patch 040501 - add dataLen check: if (patch) else ...  */
      if (dataLen < CPHS_MIN_INS_SIZE )
      {
        cphs_data->simStatus = SIMOP_UNKNOWN;
        cphs_data->infoEntry->result = SIMOP_READ_ERR;
      }
      else
        Cphs_req_info_num_read(cphs_data->startIdx, dataLen);
    }
    else /* Read list of information numbers */
    {
      /* VO patch 040501 - add dataLen check: if (patch) else ...  */
      if (dataLen >= CPHS_MIN_INS_SIZE )
      {
        if (cphs_data->idxLevel EQ 1) /* read this entry */
          Cphs_read_info_num(table_id);
        else    /* read the startIndex record */
          Cphs_req_info_num_read(cphs_data->startIdx, dataLen);
      }
    }
  }
}
T_PHB_NPI cvtNpi(T_ACI_TOA_NPI npi)
{
    switch (npi)
	{
    case NPI_NotPresent:
    case NPI_Unknown:       return CPHS_NPI_UNKNOWN;
    case NPI_IsdnTelephony: return CPHS_NPI_ISDN;
    case NPI_Data:          return CPHS_NPI_DATA;
    case NPI_Telex:         return CPHS_NPI_TELEX;
    case NPI_Private:       return CPHS_NPI_PRIVATE;
    case NPI_National:      return CPHS_NPI_NATIONAL;
#ifdef FF_2TO1_PS
    case NPI_Ermes:         return CPHS_NPI_M_ERMES;
    case NPI_Cts:           return CPHS_NPI_M_CTS;
#else
    case NPI_ERMES:         return CPHS_NPI_M_ERMES;
    case NPI_CTS:           return CPHS_NPI_M_CTS;
#endif
    default:                return npi;
	}
}
/*
+---------------------------------------------------------------------+
|         MODULE  : CPHS standalone module            |
| 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   <  CPHS_MIN_INS_SIZE                    )
  {
    if (cphs_data->simStatus EQ SIMOP_READ_OK) /* Read entry of information numbers */
    {
      cphs_data->simStatus = SIMOP_UNKNOWN;
      cphs_data->infoEntry->result = SIMOP_READ_ERR;
      TRACE_EVENT("Info num read error");
       if (cphs_data->InfoNumberCB != NULL)
      		(cphs_data->InfoNumberCB)(NULL, cphs_data->infoEntry);

    }
    else
    {// if we are here then its possible the read of 7F20 6F19 failed.
     // so we must try reading 7F10 EA01 instead.

     if (cphs_data->cphsPrevRead EQ SIM_CPHS_INFN2)
     {
      if (!Cphs_read_sim_rcd(SIM_CPHS_INFN2, 1, 0))
      {
        cphs_data->infoEntry->result = SIMOP_READ_ERR;
         if (cphs_data->InfoNumberCB != NULL)
        		(cphs_data->InfoNumberCB)(NULL, cphs_data->infoEntry);
      }
      else
      {
        cphs_data->cphsPrevRead = SIM_CPHS_INFN2;
      }
     }
     else
     { 	if (cphs_data->InfoNumberListCB != NULL)
     		(cphs_data->InfoNumberListCB)(cphs_data->numList, NULL);
     }
    }
  	(cphs_data->InfoNumberListCB)(cphs_data->numList, NULL);
  }
  else
  {
    if (cphs_data->simStatus EQ SIMOP_READ_OK)
    {
      /* Read entry of information numbers */
      alphaLen = *pData;
      if (alphaLen)
      {
        /* copy/encode entry */
        cphs_data->infoEntry->index   = recNr;
        cphs_data->infoEntry->entryStat = *(pData + 1);

        cmhPHB_getMfwTagNt(pData + 2, alphaLen,
                          cphs_data->infoEntry->alpha.data, &cphs_data->infoEntry->alpha.len);

        pData += alphaLen + 2;

        if (*pData NEQ 0xFF)
        {
          cmhPHB_getAdrStr ( (CHAR *)cphs_data->infoEntry->number,
                             3,          /* length of number */
                             pData + 2,
                             *pData );
          cmhPHB_toaDmrg ( *( pData + 1 ), &type );
          cphs_data->infoEntry->ton = cvtTon(type.ton);
          cphs_data->infoEntry->npi = cvtNpi(type.npi);
          cphs_data->infoEntry->entryStat = cphs_data->infoEntry->entryStat | 0x80;
        }
        else
        {
          cphs_data->infoEntry->number[0] = '\0';
          cphs_data->infoEntry->ton       = CPHS_TON_UNKNOWN;
          cphs_data->infoEntry->npi       = CPHS_NPI_UNKNOWN;
        }
      }
      cphs_data->infoEntry->result = SIMOP_READ_OK;
      if (cphs_data->InfoNumberCB != NULL)
      	(cphs_data->InfoNumberCB)((T_CPHS_INFO_NUM_LIST*)NULL, cphs_data->infoEntry);
      return;
    }

    else if ((*(pData + 1) & 0x0F) > cphs_data->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 */
        cphs_data->numList->level = cphs_data->idxLevel;
        cphs_data->numList->entry[cphs_data->numList->count].index   = recNr;
        cphs_data->numList->entry[cphs_data->numList->count].entryStat = *(pData + 1) & 0x7F;   /* set bit 8 to 0 */

        cmhPHB_getMfwTagNt(pData + 2, alphaLen,
                           cphs_data->numList->entry[cphs_data->numList->count].alpha.data,
                           &cphs_data->numList->entry[cphs_data->numList->count].alpha.len);

        pData += alphaLen + 2;

        if (*pData NEQ 0xFF)
        {
          cphs_data->numList->entry[cphs_data->numList->count].entryStat = cphs_data->numList->entry[cphs_data->numList->count].entryStat | 0x80;
        }
        cphs_data->numList->count++;
      }
      recNr++;
      /* Read the next record */
      Cphs_req_info_num_read(recNr, dataLen);
    }
  }
}


/*
+------------------------------------------------------------------------+
| MODULE  : CPHS standalone module               						|
| 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 > cphs_data->maxRec)
  {  if (cphs_data->InfoNumberListCB != NULL)
  		(cphs_data->InfoNumberListCB)(cphs_data->numList, (T_CPHS_INFO_NUM_ENTRY*) NULL);

  	return;
  	}
  else
  {
    if (cphs_data->cphsPrevRead EQ SIM_CPHS_INFN)
    {
      if (Cphs_read_sim_rcd(SIM_CPHS_INFN, rcd_num, dataLen))
      {

        cphs_data->cphsPrevRead = SIM_CPHS_INFN;
      }
    }
    else
    {
      if (cphs_data->cphsPrevRead EQ SIM_CPHS_INFN2)
      {
        if (!Cphs_read_sim_rcd(SIM_CPHS_INFN2, rcd_num, dataLen))
        	 if (cphs_data->InfoNumberListCB != NULL)
				(cphs_data->InfoNumberListCB)(cphs_data->numList, (T_CPHS_INFO_NUM_ENTRY*) NULL);
        else
        {
          cphs_data->cphsPrevRead = SIM_CPHS_INFN2;
        }
      }
    }
  }
}

/*
+----------------------------------------------------------------------+
|          MODULE: CPHS standalone module               |
| STATE  : code                         ROUTINE: Cphs_build_mbn_data   |
+----------------------------------------------------------------------+


   PURPOSE :   Build mailbox number data in SIM format.

*/

void Cphs_build_mbn_data(UBYTE *data, UBYTE len)
{
  UBYTE     alphaLen;
  UBYTE     numLen;
  UBYTE     *pNumber;
  UBYTE     i, j;

  TRACE_FUNCTION ("Cphs_build_mbn_data()");

  memset(data, MFW_INVALID_SIM_DATA, len);

  /* alpha data */
  if (len <= CPHS_MIN_MBN_SIZE)
    alphaLen = 0;
  else
    alphaLen = len - CPHS_MIN_MBN_SIZE;
  i = MINIMUM (alphaLen, cphs_data->vcEntry->alpha.len);

  for ( j = 0; j < i; j++ )
    data[j] = cphs_data->vcEntry->alpha.data[j];

  data += alphaLen;

  /* number data and TON/NPI data */
  if ( cphs_data->vcEntry->number[0] EQ '+' )
  {
    cphs_data->vcEntry->ton = TON_International;
    pNumber  = &cphs_data->vcEntry->number[1];
  }
  else
    pNumber  = &cphs_data->vcEntry->number[0];

  cmhPHB_getAdrBcd ( data + 2, &numLen,
                     PHB_MAX_LEN, (CHAR *)pNumber );
  *data      = numLen + 1;
  *(data + 1) = ((( cphs_data->vcEntry -> ton << 4 ) & 0xF0 ) + ( cphs_data->vcEntry -> npi & 0x0F )) | 0x80;

  data += 12;

  /* capability/configuration identifier data and EXT identifier data */
  *data      = 0xFF;
  *(data + 1) = 0xFF;
}

/*
+--------------------------------------------------------------------------+
|         MODULE  : CPHS standalone module                 |
| 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
  EF_MBN              mbn;
  #else
  T_PSPDF_MBN              mbn;
  #endif
  
  T_ACI_TOA           numTp;
  int                 i;
  USHORT              max_rcd;
TRACE_FUNCTION("Cphs_read_eeprom_mailbox()");
  for (i=0; i<MAX_CPHS_ENTRY; i++)
  {
   //switching from PCM to FFS
#ifdef PCM_2_FFS   
    if (ffs_fread("/Mailbox_no", &mbn, sizeof(mbn)) EQ EFFS_OK)
#else
    if (FFS_fread("/Mailbox_no", &mbn, sizeof(mbn)) EQ EFFS_OK)
#endif
    {
      if (mbn.len)
      {
        cphs_data->mbNum.entries[cphs_data->mbNum.count].index = i+1;
        cmhPHB_getAdrStr ( (char *)cphs_data->mbNum.entries[cphs_data->mbNum.count].number,
                           PHB_MAX_LEN - 1, mbn.mbNum, mbn.len );
        cmhPHB_getMfwTagNt ( mbn.alphId, 10,
                             cphs_data->mbNum.entries[cphs_data->mbNum.count].alpha.data,
                             &cphs_data->mbNum.entries[cphs_data->mbNum.count].alpha.len );
        cmhPHB_toaDmrg ( mbn.numTp, &numTp );
        cphs_data->mbNum.entries[cphs_data->mbNum.count].ton = cvtTon(numTp.ton);
        cphs_data->mbNum.entries[cphs_data->mbNum.count].npi = cvtNpi(numTp.npi);
        cphs_data->mbNum.entries[cphs_data->mbNum.count].service = i;
        cphs_data->mbNum.count++;
      }
    }
  }
}

/*
+---------------------------------------------------------------------------+
|         MODULE  : CPHS standalone module                  |
| STATE   : code                        ROUTINE : Cphs_write_eeprom_mailbox |
+---------------------------------------------------------------------------+

  PURPOSE : Write mailbox number in EEPROM

*/

void Cphs_write_eeprom_mailbox(T_CPHS_MAILBOX_NUM_ENTRY *entry)
{
  T_ACI_PB_TEXT text;
  UBYTE         len;
  
#ifdef PCM_2_FFS
  EF_MBN        mbn;
 #else
  T_PSPDF_MBN     mbn;
 #endif
 
  T_ACI_TOA     type;
  UBYTE         *pNumber;
  UBYTE         result;
  UBYTE         outLen;
  TRACE_FUNCTION("Cphs_write_eeprom_mailbox");

  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, mbn.alphId, &outLen, MAX_PCM_MAILBOX_LEN );

  if ( entry->number[0] EQ '+')
  {
    type.ton = TON_International;
    pNumber = &entry->number[1];
  }
  else
  {
    type.ton = entry->ton;
    pNumber = &entry->number[0];
  }
  type.npi = entry->npi;
  //MC- switching from PCM to FFS
  cmhPHB_toaMrg ( &type, &mbn.numTp );

  cmhPHB_getAdrBcd ((UBYTE*) mbn.mbNum, &mbn.len,
                    MAX_PCM_MAILBOX_LEN, (CHAR *)pNumber );
 mbn.len++;

  //if (pcm_WriteRecord((UBYTE *)EF_MBN_ID, (USHORT)entry->index,
  //                    SIZE_EF_MBN, (UBYTE *)&mbn) EQ PCM_OK)
 // if (flash_write() EQ EFFS_OK)
 #ifdef PCM_2_FFS
 if (ffs_fwrite("/Mailbox_no", &mbn, sizeof(mbn)) EQ EFFS_OK)
#else
 if (FFS_fwrite("/Mailbox_no", &mbn, sizeof(mbn)) EQ EFFS_OK)
#endif
    cphs_data->mbNum.result = SIMOP_WRITE_OK;
  else
    cphs_data->mbNum.result = SIMOP_WRITE_ERR;

}


/*
+----------------------------------------------------------------------+
|         MODULE  : CPHS standalone module             |
| STATE   : code                        ROUTINE : Cphs_select_info_num |
+----------------------------------------------------------------------+

  PURPOSE : read a information number entry

*/

void Cphs_select_info_num (UBYTE index)
{
  TRACE_FUNCTION ("Cphs_select_info_num()");

  /* check CPHS service table */
  if (cphs_data->cphsStatus EQ CPHS_NOT_PRESENT)
    return ;

  /* Read a information number entry.
     When this reading failed, send event with "read error" parameter to MMI */
  cphs_data->simStatus = SIMOP_READ_OK;
  cphs_data->startIdx  = index;

  // By now we know if 6F19 or EA01 are present for reading info. num entries from
  // So lets use this knowledge.

  if (cphs_data->cphsPrevRead EQ SIM_CPHS_INFN)
  {
    if (!Cphs_read_sim_rcd(SIM_CPHS_INFN, 1, 0))
    {
      cphs_data->infoEntry->result = SIMOP_READ_ERR;
      //cphs_sign_exec(E_CPHS_GET_INFO_NUM, &infoEntry);
       (cphs_data->InfoNumberCB)((T_CPHS_INFO_NUM_LIST*) NULL, cphs_data->infoEntry);
    }
    else
    {
      cphs_data->cphsPrevRead = SIM_CPHS_INFN;
    }
  }
  else
  {
    if (cphs_data->cphsPrevRead EQ SIM_CPHS_INFN2)
    {
      if (!Cphs_read_sim_rcd(SIM_CPHS_INFN2, 1, 0))
      {
        cphs_data->infoEntry->result = SIMOP_READ_ERR;
        //cphs_sign_exec(E_CPHS_GET_INFO_NUM, &infoEntry);
         (cphs_data->InfoNumberCB)((T_CPHS_INFO_NUM_LIST*)NULL, cphs_data->infoEntry);
      }
      else
      {
        cphs_data->cphsPrevRead = SIM_CPHS_INFN2;
      }
    }
  }
}



/*
+-----------------------------------------------------------------------+
|         MODULE  : CPHS standalone module              |
| STATE   : code                        ROUTINE : Cphs_read_ons 			  |
+-----------------------------------------------------------------------+

  PURPOSE : Read operator name short form

*/

void Cphs_read_ons(SHORT 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 */
  {
    cphs_data->opName.long_name.len = 0;
  }
  else
  {
    cmhPHB_getMfwTagNt(ptr, (UBYTE)MINIMUM(LONG_NAME, dataLen),
                       cphs_data->opName.long_name.data, &cphs_data->opName.long_name.len);
    //cphs_data->opName.long_name.dcs = MFW_DCS_SIM;

    /* Read operator name shortform */
    if ((cphs_data->cphsPhase NEQ 2)                                                          OR
        (Cphs_ssc(CHPS_NAME_SHORT,   cphs_data->cphsServTab) NEQ ALLOCATED_AND_ACTIVATED) OR
        !Cphs_read_sim_dat(SIM_CPHS_ONSHF, NOT_PRESENT_8BIT, CPHS_ONSF_SIZE)                  )
    {
      cphs_data->opName.short_name.len = 0;
    }
  }
}

/*
+-----------------------------------------------------------------------+
|         MODULE  : CPHS standalone module              				|
| STATE   : code                        ROUTINE : Cphs_read_onsf			  |
+-----------------------------------------------------------------------+

  PURPOSE : Read operator name short form

*/

void Cphs_read_onsf(SHORT 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 < CPHS_ONSF_SIZE )
  {
    cphs_data->opName.short_name.len = 0;
  }
  else
  {
    cmhPHB_getMfwTagNt(ptr, CPHS_ONSF_SIZE,
                       cphs_data->opName.short_name.data, &cphs_data->opName.short_name.len);
    //cphs_data->opName.shortName.dcs = MFW_DCS_SIM;
  }

  //cphs_sign_exec(E_CPHS_OP_NAME, &opName);
}

/*
+-----------------------------------------------------------------------+
|         MODULE  : CPHS standalone module              				|
| STATE   : code                        ROUTINE : cvtTon				|
+-----------------------------------------------------------------------+

  PURPOSE : Convert Type of Number

*/


T_CPHS_PHB_TON cvtTon(T_ACI_TOA_TON ton)
{
    switch (ton)
	{
    case TON_NotPresent:
    case TON_Unknown:           return CPHS_TON_UNKNOWN;
    case TON_International:     return CPHS_TON_INTERNATIONAL;
    case TON_National:          return CPHS_TON_NATIONAL;
    case TON_NetSpecific:       return CPHS_TON_NET_SPECIFIC;
    case TON_DedAccess:         return CPHS_TON_DED_ACCESS;
    case TON_Alphanumeric:      return CPHS_TON_ALPHA_NUMERIC;
    case TON_Abbreviated:       return CPHS_TON_ABBREVIATED;
    case TON_Extended:          return CPHS_TON_EXTENDED;
		default:					          return ton;
	}
}
/*
+-----------------------------------------------------------------------+
| MODULE  : CPHS standalone module              						|
| STATE   : code                        ROUTINE : cphs_read_mbn  		|
+-----------------------------------------------------------------------+

  PURPOSE : Read mailbox number into runtime variables

*/
void Cphs_read_mbn(SHORT table_id)
{
  UBYTE*        pData;         /* points to data buffer    */
  UBYTE         alphaLen;
  UBYTE         dataLen;
  UBYTE         recNr;
  T_ACI_TOA     type;

  TRACE_FUNCTION ("Cphs_read_mbn()");

  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   <  CPHS_MIN_MBN_SIZE )
  {//MC FFS ?
   /* if (recNr <= 1)
    {
      Cphs_read_eeprom_mailbox();
      return;
    }
    else
      cphs_sign_exec(E_CPHS_GET_VC_NUM, &mbNum);*/
      TRACE_EVENT("MB read error");
      return;
  }
  else /* no read error */
  {
    if (recNr EQ 1)
    {
      cphs_data->maxRec = simShrdPrm.atb[table_id].recMax;
    }
    alphaLen = dataLen - CPHS_MIN_MBN_SIZE;

    /* Copy/encode data */
    if (*(pData + alphaLen + 2) NEQ 0xFF)
    {
      cphs_data->mbNum.entries[cphs_data->mbNum.count].index = recNr;
      cmhPHB_getMfwTagNt(pData, alphaLen,
                         cphs_data->mbNum.entries[cphs_data->mbNum.count].alpha.data,
                         &cphs_data->mbNum.entries[cphs_data->mbNum.count].alpha.len);
      pData += alphaLen;

      cmhPHB_getAdrStr ( (CHAR *)cphs_data->mbNum.entries[cphs_data->mbNum.count].number,
                         PHB_MAX_LEN - 1,
                         pData + 2,
                         *pData );

      cmhPHB_toaDmrg ( *( pData + 1 ), &type );
      cphs_data->mbNum.entries[cphs_data->mbNum.count].ton = cvtTon(type.ton);
      cphs_data->mbNum.entries[cphs_data->mbNum.count].npi = cvtNpi(type.npi);
      pData += 12;

      if ( *pData NEQ 0xFF )
      {
        /* read bearer capability EF */
        /* return; */
      }
      cphs_data->mbNum.count++;
      cphs_data->mbNum.result = SIMOP_READ_OK;
    }
    recNr++;
     if (recNr > cphs_data->maxRec)
    {	TRACE_FUNCTION("got CPHS Mailbox nos");
     Cphs_operator_name();//get next CPHS item
      return;

    }
    if (recNr <= cphs_data->maxRec)
    {
      /* Read the next entry */
      Cphs_read_sim_rcd(SIM_CPHS_MBXN, recNr, dataLen);
    }


  }
}

/*
+-----------------------------------------------------------------------+
|         MODULE  : CPHS standalone module              |
| STATE   : code                        ROUTINE : Cphs_read_mbs 			  |
+-----------------------------------------------------------------------+

  PURPOSE : Read voice message waiting flag

*/

void Cphs_read_mbs(SHORT errCode, UBYTE *data, UBYTE dataLen)
{
  UBYTE *ptr;
  int   i; /* PATCH VO 22.01.01 */
  char debug[50];

  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 < MFW_CPHS_MBS_SIZE  )
       dataLen <= 0  )  /* PATCH VO 22.01.01: not check a certain length */
  {
    cphs_data->mbStatus.result = SIMOP_READ_ERR;
  }
  else
  {
sprintf(debug, "Retrieved mailbox status: %x%x",ptr[0],ptr[1]);
  TRACE_EVENT(debug);
    memset(&cphs_data->mbStatus, CPHS_FLAG_NOT_PRESENT, sizeof(cphs_data->mbStatus));
    cphs_data->mbStatus.result = SIMOP_READ_OK;
    for (i=0; i<dataLen; i++)
    {
      switch (i)
      {
        case 0:
          cphs_data->mbStatus.line1  = ptr[i] & 0x0F/*0x01*/;
          cphs_data->mbStatus.line2  = ( ptr[i] >> 4 ) & 0x0F/*0x01*/;
          break;
        case 1:
          cphs_data->mbStatus.fax    = ptr[i] & 0x0F/*0x01*/;
          cphs_data->mbStatus.data   = ( ptr[i] >> 4 ) & 0x0F/*0x01*/;
          break;
        default:
          break;
      }
    }
/* PATCH VO 22.01.01 END */
//Not sure about this
//memcpy(cphs_data->mbsData, ptr, CPHS_MBS_SIZE);
  }
}

/*
+-----------------------------------------------------------------------+
|         MODULE  : CPHS standalone module              |
| STATE   : code                        ROUTINE : Cphs_read_cff 			  |
+-----------------------------------------------------------------------+

  PURPOSE : Read call forwarding flag

*/

void Cphs_read_cff(SHORT errCode, UBYTE *data, UBYTE dataLen)
{
  UBYTE *ptr;
  int   i; /* PATCH VO 22.01.01 */
  char debug[50];

  TRACE_EVENT ("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 < MFW_CPHS_CFF_SIZE  )
       dataLen <= 0  )  /* PATCH VO 22.01.01: not check a certain length */
  {
    cphs_data->dvStatus.result = SIMOP_READ_ERR;
  }
  else
  {
	sprintf(debug, "Retrieved divert status: %x%x",ptr[0],ptr[1]);
  TRACE_EVENT(debug);
    memset(&cphs_data->dvStatus, CPHS_FLAG_NOT_PRESENT, sizeof(cphs_data->dvStatus));
    cphs_data->dvStatus.result = SIMOP_READ_OK;
    for (i=0; i<dataLen; i++)
    {
      switch (i)
      {
        case 0:
          cphs_data->dvStatus.line1  = ptr[i] & /*0x0F*/0x01;
          cphs_data->dvStatus.line2  = ( ptr[i] >> 4 ) & /*0x0F*/0x01;
          break;
        case 1:
          cphs_data->dvStatus.fax    = ptr[i] & /*0x0F*/0x01;
          cphs_data->dvStatus.data   = ( ptr[i] >> 4 ) & /*0x0F*/0x01;
          break;
        default:
          break;
      }
    }
/* PATCH VO 22.01.01 END */
	//not sure about this bit
	//memcpy(cphs_data->dvData, ptr, CPHS_CFF_SIZE);
  }
}




/*
+-----------------------------------------------------------------------+
|         MODULE  : CPHS standalone module              |
| STATE   : code                        ROUTINE : Cphs_read_csp 			  |
+-----------------------------------------------------------------------+

  PURPOSE : Read customer service profile

*/

void Cphs_read_csp(SHORT 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 < MFW_CPHS_CSP_SIZE	 )
       dataLen <= 0	 )  /* PATCH VO 22.01.01: not check a certain length */
  {
    if (cphs_data->simStatus EQ SIMOP_READ_OK) /* Used for read information numbers */
    {
      cphs_data->simStatus = SIMOP_UNKNOWN;
      //cphs_sign_exec(E_CPHS_GET_INFO_LIST, &numList);
    }
    else
    {
      cphs_data->csProfile.result = SIMOP_READ_ERR;
      memset(cphs_data->csProfile.csp, 0, sizeof(cphs_data->csProfile.csp));
      //cphs_sign_exec(E_CPHS_GET_CSP, &csProfile);
       if (cphs_data->RefreshCB != NULL)
      	(cphs_data->RefreshCB)(NULL, NULL);
    }
  }
  else
  {
    if (cphs_data->simStatus EQ SIMOP_READ_OK) /* Used for read information numbers */
    {
      cphs_data->simStatus = SIMOP_UNKNOWN;

      /* check the service group code */
      flag = 0;
      //for (i = 0; i < MFW_CPHS_CSP_SIZE; i += 2)
      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_sign_exec(E_CPHS_GET_INFO_LIST, &numList);
        return;
      }

      /* Read the first information numbers record */
      if (!Cphs_read_sim_rcd(SIM_CPHS_INFN, 1, 0))
       { //cphs_sign_exec(E_CPHS_GET_INFO_LIST, &numList);
		TRACE_EVENT("Can't read info num rcd");
   		return;
      	}

      else
        cphs_data->cphsPrevRead = SIM_CPHS_INFN;
    }
    else
    {
      cphs_data->csProfile.result = SIMOP_READ_OK;
      TRACE_EVENT("CPHS valid CSP");
      //memcpy(cphs_data->csProfile.csp, ptr, sizeof(cphs_data->csProfile.csp));
      for (i=0; i<(dataLen/2); i++)
      	{
      		cphs_data->csProfile.csp[i].group_code = ptr[2*i];
      		cphs_data->csProfile.csp[i].services =ptr[2*i + 1];
      	}
       if (cphs_data->RefreshCB != NULL)
      	(cphs_data->RefreshCB)(NULL, NULL);
     // cphs_sign_exec(E_CPHS_GET_CSP, &cphs_data->csProfile);
    }
  }
}

void Cphs_read_information(SHORT errCode, UBYTE *data, UBYTE dataLen)
{
  UBYTE *ptr;

  UBYTE len;


  TRACE_FUNCTION ("Cphs_read_information()");

  ptr = data;

  len = dataLen;
  memset(cphs_data->cphsServTab, 0, sizeof(cphs_data->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 < MFW_CPHS_INFO_SIZE)
       dataLen <= 0) /* PATCH VO 22.01.01: not check a certain length */
  {
    cphs_data->cphsStatus = CPHS_NOT_PRESENT;
    //cphs_sign_exec(E_CPHS_IND, &cphsStatus);
  }
  else
  {
    cphs_data->cphsPhase = *ptr;
    len--;
    if (len > 0)
    {
      ptr++;
      memcpy (cphs_data->cphsServTab, ptr, MINIMUM(len, CPHS_SERVICE_TABLE));
    }
/* PATCH VO 22.01.01 END */
    cphs_data->cphsStatus = CPHS_IS_OK;
	TRACE_EVENT("CPHS supported");
    //cphs_sign_exec(E_CPHS_IND, &cphsStatus);
  }
}
#ifdef FRED //commented this func out because of build problems
#ifdef SIM_TOOLKIT
/*
+---------------------------------------------------------------------+
|    MODULE  : CPHS standalone module                 |
| STATE   : code                   ROUTINE : Cphs_update_info_cnf     |
+---------------------------------------------------------------------+

  PURPOSE : call back for SIM file read

*/

void Cphs_update_info_cnf (SHORT errCode, UBYTE *data, UBYTE dataLen)
{
  UBYTE *ptr;

  TRACE_FUNCTION ("Cphs_update_info_cnf()");

  cphs_data->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 < CPHS_INFO_SIZE)
  {
    satUpdateFiles(TRUE, SIM_CPHS_CINF);
  }
  else
  {
    cphs_data->cphsPhase = *ptr;
    ptr++;
    memcpy (cphs_data->cphsServTab, ptr, CPHS_SERVICE_TABLE*sizeof(UBYTE));
    cphs_data->cphsStatus = CPHS_IS_OK;
    satUpdateFiles ( TRUE, SIM_CPHS_CINF );
  }
}
#endif
#endif
BOOL Cphs_write_sim_dat(USHORT data_id, UBYTE *data, UBYTE length)
{
  T_ACI_RETURN res;

  TRACE_FUNCTION ("Cphs_write_sim_dat()");

  res = cmhSIM_WriteTranspEF (CMD_SRC_NONE,
                              AT_CMD_NONE,
                              data_id,
                              0,
                              length,
                              data,
                              Cphs_write_sim_dat_cb);

  if (res NEQ AT_EXCT)
    return FALSE;

  return TRUE;
}

/*
+----------------------------------------------------------------------+
|          MODULE: CPHS standalone module               |
| 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;
	char debug[30];
  TRACE_FUNCTION ("sim_write_sim_dat_cb()");


  sprintf(debug, "SIM Error code!!!%d", simShrdPrm.atb[table_id].errCode);
  TRACE_EVENT(debug);
  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
      {
        cphs_data->mbStatus.result = SIMOP_WRITE_OK;

      }
      else
      {
        cphs_data->mbStatus.result = SIMOP_WRITE_ERR;
      }
      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
      {
        cphs_data->dvStatus.result = SIMOP_WRITE_OK;
       TRACE_EVENT("Divert Write successful");
      }
      else
      {
        cphs_data->dvStatus.result = SIMOP_WRITE_ERR;
        TRACE_EVENT("Divert Write Failed");
      }
      break;

    default:
      break;
  }
  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
}

/*
+-----------------------------------------------------------------------+
| MODULE  : CPHS standalone module              |
| STATE   : code                        ROUTINE : cphs_read_eeprom_als  |
+-----------------------------------------------------------------------+

  PURPOSE : Read alternate line service information from EEPROM

*/

T_CPHS_RET Cphs_read_eeprom_als(T_CPHS_ALS_INFO* info)
{	char read_result;
	char debug[50];

#ifdef PCM_2_FFS
 	read_result =ffs_fread("/AlsInfo",  info, sizeof(T_CPHS_ALS_INFO));
#else
 	read_result =FFS_fread("/AlsInfo",  info, sizeof(T_CPHS_ALS_INFO));
#endif

 	if (read_result == EFFS_OK)
 	{	info->result = SIMOP_READ_OK;
		return CPHS_IS_OK;
 	}
 	else
 	{	info->result = SIMOP_READ_ERR;
 		sprintf(debug, "ALS info read error:%d", read_result);
 		TRACE_EVENT(debug);
 		return CPHS_SIM_READ_ERROR;
 	}
}

/*
+-----------------------------------------------------------------------+
| MODULE  : CPHS standalone module         						     |
| STATE   : code                        ROUTINE : cphs_write_eeprom_als |
+-----------------------------------------------------------------------+

  PURPOSE : Write selected alternate line/lock status in EEPROM

*/

T_CPHS_RET Cphs_write_eeprom_als(T_CPHS_ALS_INFO* info)
{	char write_result;
	T_ACI_ALS_MOD alsMode;
	T_CPHS_RET return_result;

#ifdef PCM_2_FFS
 	write_result =ffs_fwrite("/AlsInfo",  info, sizeof(T_CPHS_ALS_INFO));
#else
 	write_result =FFS_fwrite("/AlsInfo",  info, sizeof(T_CPHS_ALS_INFO));
#endif

 	if (write_result >= EFFS_OK)
 	{	info->result = SIMOP_WRITE_OK;
 		return_result = CPHS_IS_OK;
 		TRACE_EVENT("ALS info write OK");
 	}
 	else
 	{	info->result = SIMOP_WRITE_ERR;
		return_result = CPHS_SIM_WRITE_ERROR;
		TRACE_EVENT("ALS info write error");
 	}

 	  if (cphs_data->alsStatus.line  EQ CPHS_LINE_INDEX_LINE1)
        alsMode = ALS_MOD_SPEECH;
      if (cphs_data->alsStatus.line EQ CPHS_LINE_INDEX_LINE2)
        alsMode = ALS_MOD_AUX_SPEECH;
      sAT_PercentALS(CMD_SRC_LCL, alsMode);
    return return_result;

}
/*
+-----------------------------------------------------------------------+
| MODULE  : CPHS standalone module         						     	|
| STATE   : code                        ROUTINE : cphs_write_eeprom_als_desc |
+-----------------------------------------------------------------------+

  PURPOSE : Write ALS line description in EEPROM

*/
void Cphs_write_eeprom_als_desc(T_CPHS_ALS_LINE* line)
{	char write_result = -1;
	T_CPHS_ALS_LINE* desc;
	if (line->line EQ CPHS_LINE_INDEX_LINE1)
	{	desc = &cphs_data->Line1_desc;
	
#ifdef PCM_2_FFS	
	 	write_result =ffs_fwrite("/AlsDesc1",  &cphs_data->Line1_desc, sizeof(cphs_data->Line1_desc));
#else
	 	write_result =FFS_fwrite("/AlsDesc1",  &cphs_data->Line1_desc, sizeof(cphs_data->Line1_desc));
#endif

	}
	if (line->line EQ CPHS_LINE_INDEX_LINE2)
	{	desc = &cphs_data->Line2_desc;
#ifdef PCM_2_FFS	
	 	write_result =ffs_fwrite("/AlsDesc2",  &cphs_data->Line2_desc, sizeof(cphs_data->Line1_desc));
#else
	 	write_result =FFS_fwrite("/AlsDesc2",  &cphs_data->Line2_desc, sizeof(cphs_data->Line1_desc));
#endif
	}

	 if (write_result >= EFFS_OK)
	 		desc->result = SIMOP_WRITE_OK;
	 	else
	 		desc->result = SIMOP_WRITE_ERR;
}
/*
+-----------------------------------------------------------------------+
| MODULE  : CPHS standalone module         						     	|
| STATE   : code                        ROUTINE : cphs_read_eeprom_als_desc |
+-----------------------------------------------------------------------+

  PURPOSE : read ALS line description from EEPROM

*/
void Cphs_read_eeprom_als_desc()
{	char read_result = -1;
	T_CPHS_ALS_LINE* desc;

#ifdef PCM_2_FFS
	 	read_result =ffs_fread("/AlsDesc1",  &cphs_data->Line1_desc, sizeof(cphs_data->Line1_desc));
#else
	 	read_result =FFS_fread("/AlsDesc1",  &cphs_data->Line1_desc, sizeof(cphs_data->Line1_desc));
#endif
	 	if (read_result >= EFFS_OK)
	 		cphs_data->Line1_desc.result = SIMOP_READ_OK;
	 	else
			cphs_data->Line1_desc.result = SIMOP_READ_ERR;


#ifdef PCM_2_FFS
	 	read_result =ffs_fread("/AlsDesc2",  &cphs_data->Line2_desc, sizeof(cphs_data->Line1_desc));
#else
	 	read_result =FFS_fread("/AlsDesc2",  &cphs_data->Line2_desc, sizeof(cphs_data->Line1_desc));
#endif
	 	if (read_result EQ EFFS_OK)
	 		cphs_data->Line2_desc.result = SIMOP_READ_OK;
	 	else
			cphs_data->Line2_desc.result = SIMOP_READ_ERR;


}

void Cphs_get_info_num (UBYTE level, UBYTE startIndex)
{
  UBYTE res;

  TRACE_FUNCTION ("cphs_get_info_num()");

  /* check CPHS service table */
  if (cphs_data->cphsStatus EQ CPHS_NOT_PRESENT)
    return;

  if (level < 1       OR
      startIndex < 1    )
    return;

  /* check CPHS service table for customer service profile */
 /* res = Cphs_ssc(CPHS_CSP, cphs_data->cphsServTab);
  if ( res NEQ ALLOCATED_AND_ACTIVATED)
    return;*/

  /* check CPHS service table for information numbers */
/*  res = Cphs_ssc(CHPS_INFO_NUMBERS, cphs_data->cphsServTab);
  if ( res NEQ ALLOCATED_AND_ACTIVATED)
    return;*/

  /* Read customer service profile to check
     whether information numbers are supported.       */
  cphs_data->numList->count = 0;
  cphs_data->idxLevel      = level;
  cphs_data->startIdx      = startIndex;
  cphs_data->simStatus = SIMOP_READ_OK;
  if (!Cphs_read_sim_dat(SIM_CPHS_CSP, NOT_PRESENT_8BIT, CPHS_CSP_SIZE))
  {
    cphs_data->simStatus = SIMOP_UNKNOWN;
    TRACE_EVENT("FAiled in reading CSP for Info nums");
    return;
  }

  return;
}


/* checks the lock status of the given lock type. On successfull check   */
/* the status will be returned. If an error occured SIMLOCK_FAIL will    */
T_SIMLOCK_RET simlock_checkLock   ( T_SIMLOCK_TYPE type )
{

	return SIMLOCK_FAIL;
}