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