FreeCalypso > hg > tcs211-l1-reconst
diff g23m/condat/ms/src/mfw/CPHS_mod.c @ 0:509db1a7b7b8
initial import: leo2moko-r1
| author | Space Falcon <falcon@ivan.Harhan.ORG> |
|---|---|
| date | Mon, 01 Jun 2015 03:24:05 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/g23m/condat/ms/src/mfw/CPHS_mod.c Mon Jun 01 03:24:05 2015 +0000 @@ -0,0 +1,2971 @@ +/*-----------------------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; +} +