mcu/interface/protocol/l2_c2k/common/hlpdef.h

/*****************************************************************************
*  Copyright Statement:
*  --------------------
*  This software is protected by Copyright and the information contained
*  herein is confidential. The software may not be copied and the information
*  contained herein may not be used or disclosed except with the written
*  permission of MediaTek Inc. (C) 2016
*
*  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
*  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS (""MEDIATEK SOFTWARE"")
*  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
*  AN ""AS-IS"" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
*  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
*  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
*  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
*  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
*  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
*  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
*  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
*  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
*
*  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
*  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
*  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
*  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
*  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
*
*  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
*  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
*  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
*  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
*  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
*
*****************************************************************************/
/*************************************************************
*
* This Software is the property of VIA Telecom, Inc. and may only be used pursuant to a license from VIA Telecom, Inc.
*
* Any unauthorized use inconsistent with the terms of such license is strictly prohibited.
*
* Copyright (c) 1998-2010 VIA Telecom, Inc.  All rights reserved.
*
*************************************************************/
#ifndef _HLPDEF_H_
#define _HLPDEF_H_
/*****************************************************************************
*
* FILE NAME   : hlpdef.h
*
* DESCRIPTION :
*
*     This include file provides unit wide regional type declarations and
*     constants
*
* HISTORY     :
*     See Log at end of file.
*
*****************************************************************************/

/*----------------------------------------------------------------------------
 Include Files
----------------------------------------------------------------------------*/
#include "valapi.h"
#include "hlpcam.h"
#include "do_rcpapi.h"
#include "reg_base.h"
#include "cssapi.h"
#include "do_almpapi.h"
#include "hlpem.h"
#include "sim_exported_enum.h"

/*----------------------------------------------------------------------------
 Global Defines and Macros
----------------------------------------------------------------------------*/
#define MAX_SIZE_REVERSE_BUFFER   512
#define MAX_NUM_DATA_PAGE         2
#define MAX_NUMBER_OF_TIMERS      20
#define MAX_NUM_DECODE_RESULTS    20
#define WFR_HAND_OFF_HYST_TMR     10000

#define START_DECODER_OPERATION   0x0001
#define DEFAULT_DECODER_CONFIG    0x0350
#define START_ENCODER_OPERATION   0x0001
#define DEFAULT_ENCODER_CONFIG    0x0350

#define PPPReMap(data)            ((kal_uint32)(data))
#define PPP_MAX_ENC0_SRC          75       /* 75  entries max. */
#define PPP_MAX_ENC1_SRC          150      /* 150 entries max. */
#define PPP_MAX_RESULT0           75       /* 75  entries max. */
#define PPP_MAX_RESULT1           150      /* 150 entries max. */
#define PPP_MAX_LLD0              480      /* 480 entries max. */
#define PPP_MAX_LLD1              480      /* 480 entries max. */

#define PPP_MAX_DEST0             0x8000   /* 32K bytes.       */
#define PPP_MAX_DEST1             0x4000   /* 64K bytes.       */

/*---------------------------------
Foward path : ENC0 & DEC0
Reverse path: ENC1 & DEC1
----------------------------------*/
#define PPPHA_BASE_ADDR           BASE_MADDR_MDINFRA_PPPHA
#define PPP_ENC0_SRC_ADR          (PPPHA_BASE_ADDR + 0x0000)
#define PPP_ENC0_DST_ADR          (PPPHA_BASE_ADDR + 0x0004)
#define PPP_ENC0_TRNSCNT          (PPPHA_BASE_ADDR + 0x0008)
#define PPP_ENC0_CNFG             (PPPHA_BASE_ADDR + 0x000C)
#define PPP_ENC0_CNTL             (PPPHA_BASE_ADDR + 0x0010)
#define PPP_ENC0_ACCM             (PPPHA_BASE_ADDR + 0x0014)
#define PPP_ENC0_BYTECNT          (PPPHA_BASE_ADDR + 0x0018)
#define PPP_ENC0_BYTES_TOT        (PPPHA_BASE_ADDR + 0x001C)

#define PPP_ENC1_SRC_ADR          (PPPHA_BASE_ADDR + 0x0040)
#define PPP_ENC1_DST_ADR          (PPPHA_BASE_ADDR + 0x0044)
#define PPP_ENC1_TRNSCNT          (PPPHA_BASE_ADDR + 0x0048)
#define PPP_ENC1_CNFG             (PPPHA_BASE_ADDR + 0x004C)
#define PPP_ENC1_CNTL             (PPPHA_BASE_ADDR + 0x0050)
#define PPP_ENC1_ACCM             (PPPHA_BASE_ADDR + 0x0054)
#define PPP_ENC1_BYTECNT          (PPPHA_BASE_ADDR + 0x0058)
#define PPP_ENC1_BYTES_TOT        (PPPHA_BASE_ADDR + 0x005C)

#define PPP_DEC0_LLD_ADR          (PPPHA_BASE_ADDR + 0x0080)
#define PPP_DEC0_DST_ADR          (PPPHA_BASE_ADDR + 0x0084)
#define PPP_DEC0_TRNSCNT          (PPPHA_BASE_ADDR + 0x0088)
#define PPP_DEC0_CNFG             (PPPHA_BASE_ADDR + 0x008C)
#define PPP_DEC0_CNTL             (PPPHA_BASE_ADDR + 0x0090)
#define PPP_DEC0_RES_ADR          (PPPHA_BASE_ADDR + 0x0094)
#define PPP_DEC0_MAX_ADR          (PPPHA_BASE_ADDR + 0x0098)
#define PPP_DEC0_CRT_ADR          (PPPHA_BASE_ADDR + 0x009C)

#define PPP_DEC1_LLD_ADR          (PPPHA_BASE_ADDR + 0x00C0)
#define PPP_DEC1_DST_ADR          (PPPHA_BASE_ADDR + 0x00C4)
#define PPP_DEC1_TRNSCNT          (PPPHA_BASE_ADDR + 0x00C8)
#define PPP_DEC1_CNFG             (PPPHA_BASE_ADDR + 0x00CC)
#define PPP_DEC1_CNTL             (PPPHA_BASE_ADDR + 0x00D0)
#define PPP_DEC1_RES_ADR          (PPPHA_BASE_ADDR + 0x00D4)
#define PPP_DEC1_MAX_ADR          (PPPHA_BASE_ADDR + 0x00D8)
#define PPP_DEC1_CRT_ADR          (PPPHA_BASE_ADDR + 0x00DC)

#define PPP_DMA_SUSPEND           (PPPHA_BASE_ADDR + 0x00E0)

/* #define PPP_SRAM_ACCESS  0xABC0001C */

#define HLP_DEFAULT_ACCM          0xFFFFFFFF

#define HLP_BURST_LENGTH_4
#define HLP_HA_DEC_DST_BURST_LEN_MASK 0xFF3F

#if defined(HLP_BURST_LENGTH_8)   /* burst length 8 */
#define HLP_DEFAULT_HA_ENC_CFG    0x03a0
#define HLP_HA_32BIT_ENC_CFG      0x03a2
#define HLP_HA_16BIT_ENC_CFG      0x03a1

#define HLP_DEFAULT_HA_DEC_CFG    0x07a0
#define HLP_HA_32BIT_DEC_CFG      0x07a2
#define HLP_HA_16BIT_DEC_CFG      0x07a1

#elif defined(HLP_BURST_LENGTH_4) /* burst length 4 */
#define HLP_DEFAULT_HA_ENC_CFG    0x0350
#define HLP_HA_16BIT_ENC_CFG      0x0351

#define HLP_HA_32BIT_ENC_CFG      0x0368

#define HLP_DEFAULT_HA_DEC_CFG    0x07a0
#define HLP_HA_32BIT_DEC_CFG      0x07a2
#define HLP_HA_16BIT_DEC_CFG      0x07a1

#else                             /* non-burst 1 */
#define HLP_DEFAULT_HA_CFG        0x0300
#define HLP_HA_32BIT_CFG          0x0302
#define HLP_HA_16BIT_CFG          0x0301
#endif

#define TCP_TAG_NOT_PURE_ACK      38
#define TCP_TAG_PURE_ACK          49
#define TCP_TAG_RETRANSMIT        50


/* Define Macros that manages the PPP_DMA_SUSPEND register (This feature is not used) */
#define PppDmaSuspend() HwdWrite(PPP_DMA_SUSPEND, 0x0001)
#define PppDmaResume()  HwdWrite(PPP_DMA_SUSPEND, 0x0000)

#define HLP_UIM_MAX_PROFILE_NUM         16
#define HLP_UIM_MAX_MIP_ADD_ACT_NAI_NUM 16

#define WFR_PPP_RSP_TM      20000  /* 250 seconds, seems too long. changed to 10 seconds by Fenix */
#define WFR_NWK_RSP_TM      15000
#define WFR_USER_RSP_TM     60000 /*1 minute for call setup*/

/* memory size occupied by ppp header, 2B as its data type is kal_uint16 */
#define HLP_PPP_HEADER_DATA_TYPE_SIZE   sizeof(kal_uint16)

extern kal_spinlockid chlp_spinlock;

#if defined (__SMP_ARCH__)
#define CHLP_TAKE_SPINLOCK()  kal_take_spinlock(chlp_spinlock, KAL_INFINITE_WAIT)
#define CHLP_GIVE_SPINLOCK()  kal_give_spinlock(chlp_spinlock)
#else
#define CHLP_TAKE_SPINLOCK()
#define CHLP_GIVE_SPINLOCK()
#endif  /* __SMP_ARCH__ */

enum
{
   HO_NULL,
   HO_TO_DO,
   HO_TO_1X,
   HO_TO_EHRPD
};

typedef enum
{
   CAM_SYS_HSPD,
   CAM_SYS_HRPD,
   CAM_SYS_EHRPD,
   CAM_SYS_MAX
} CamSysTypeT;

typedef enum
{
   PPPHA_NOT_INITIALIZED,
   PPPHA_CLOSE_TO_END_DEC0,
   PPPHA_CLOSE_TO_END_DEC1,
   PPPHA_FLOW_CTRL_TURNED_ON,
   PPPHA_BUF_FAIL,
   PPPHA_CRC_FAIL,
   PPPHA_DEST_ADDR_NULL,
   PPPHA_STATUS_MAX
} PpphaStatusT;

typedef enum
{
   PPPHA_ENC0,/*Rev Encode*/
   PPPHA_DEC0,/*Fwd Decode*/
   PPPHA_ENC1,/*Fwd Encode*/
   PPPHA_DEC1 /*Rev Decode*/
} PpphaPhaseT;

typedef enum
{
   DATA_SERVICE_SIP,
   DATA_SERVICE_MIP,
   DATA_SERVICE_HRPD,
   DATA_SERVICE_3GPDEXT,
   DATA_SERVICE_IPv6,
   DATA_SERVICE_UST_ACL,
   DATA_SERVICE_EST_ACL
} DataServiceTypeT;

typedef enum
{
    HLP_DATA_DIR_UL,
    HLP_DATA_DIR_DL,
    HLP_DATA_DIR_MAX
}HlpDataDirEnum;

typedef enum
{
    HLP_NV_IP_COUNTER_ERR,
    HLP_NV_IP_COUNTER_LEN_ERR,
    HLP_NV_HSPD_DATA_ERR,
    HLP_NV_HSPD_DATA_LEN_ERR,
    HLP_NV_HSPD_SECURE_ERR,
    HLP_NV_HSPD_SECURE_LEN_ERR,
    HLP_NV_EHRPD_DATA_ERR,
    HLP_NV_EHRPD_DATA_LEN_ERR,
    HLP_NV_DMU_PUBKEY_ERR,
    HLP_NV_DMU_PUBKEY_LEN_ERR,
    HLP_NV_ERR_MAX
} HlpNvRdWtErrT;

typedef enum
{
   NO_SILENTLY_RETRY, /*don't retry by modem, directly notify AP*/
   SILENTLY_AFRESH_CONN,/*re-establish connection*/
   SILENTLY_AFRESH_PS,/*re-establish connection and re-nego ppp*/
   SILENTLY_PPP_RENEGO  /*re-establish PPP*/
} HlpRecoverFlagT;

typedef enum
{
    HLP_PROTOCOL_COMPRESSION,        /* Protocol Compression */
    HLP_ADDRESS_CONTROL_COMPRESSION, /* Address/Control Compression */ 
    HLP_PPP_HEADER_ENC_GETBUFF_NULL
}HlpPppHeaderEncWarningT;

typedef struct
{
   kal_uint16 tcpTag;
   kal_uint32 tcpPort;
   kal_uint32 srcIpAddr;
   kal_uint32 dstIpAddr;
}socketInfoT;

typedef struct
{
   CpBufferT*           sourceAddr;
   CpBufferT*           destAddr;
   kal_uint8*               directSrcAddr;
   kal_uint32               xferCount;
   kal_uint32               configReg;
#ifdef SYS_OPTION_PPPHA_ENC_ENH
   kal_uint8                leadingPad;
   kal_uint8                tailingPad;
#endif
   kal_uint32               accmInUse;
   kal_uint16               encodedLen;
   kal_uint16               sourceOffset;
   kal_bool                 isCpBufPtr;
   AppSubTypeT          AppSubType;
   socketInfoT          dstSocket;
} HlpPPPHaEncTableT;

typedef struct
{
   ExeRspMsgT  RspInfo;
} HlpGetIPServiceTypeMsgT;

typedef struct
{
   kal_uint8 pureAckTagRateTD;
   kal_uint8 pureAckTagRate;
} HlpEtsPureAckRateMsgT;

typedef struct
{
   kal_uint32 tmrStatusHspd;
   kal_uint32 tmrSysIdHspd[MAX_NUM_SYS_TMR_ENTRY];
   kal_uint32 tmrStatusHrpd;
   kal_uint32 tmrSysIdHrpd[MAX_NUM_SYS_TMR_ENTRY];
   kal_uint32 tmrStatusEhrpd;
   kal_uint32 tmrSysIdEhrpd[MAX_NUM_SYS_TMR_ENTRY];
} HlpEtsThrottlingTmrStatusMsgT;

#define HLP_UIM_MAX_PROFILE_NUM         16
#define HLP_UIM_MAX_MIP_ADD_ACT_NAI_NUM 16
typedef struct
{
   kal_uint8 MaxNumNAI;
   kal_uint8 MaxNAILen;
   kal_uint8 MaxSSLen;
   kal_uint8 AuthAlgo;
} HlpUim3GPDSipCapT;

typedef struct
{
   kal_uint8 MaxNumNAI;
   kal_uint8 MaxNAILen;
   kal_uint8 MaxMNAAASSLen;
   kal_uint8 MNAAAAuthAlgo;
   kal_uint8 MaxMNHASSLen;
   kal_uint8 MNHAAuthAlgo;
} HlpUim3GPDMipCapT;

typedef struct
{
   kal_uint8 NAIEntryIndex;
   kal_uint8 NAILen;
   kal_uint8 NAI[MN_NAI_MAX_SIZE];
   kal_uint8 AuthAlgo;
} HlpSipUserProfileT;

typedef struct
{
   kal_uint8 NumNAI;
   HlpSipUserProfileT SipUserProfile[HLP_UIM_MAX_PROFILE_NUM];
} HlpUim3GPDSipUserProfileT;

typedef struct
{
   kal_uint8 NAIEntryIndex;
   kal_uint8 NAILen;
   kal_uint8 NAI[MN_NAI_MAX_SIZE];
   kal_bool TBit;
   kal_uint32 HomeAddress;
   kal_uint32 PrimaryHomeAgent;
   kal_uint32 SecondaryHomeAgent;
   kal_uint8 MNAAAAuthAlgo;
   kal_bool MNAAASpiInd;
   kal_uint32 MNAAASpi;
   kal_uint8  MNHAAuthAlgo;
   kal_bool MNHASpiInd;
   kal_uint32 MNHASpi;
} HlpMipUserProfileT;

typedef struct
{
   kal_bool RetryInfoIncluded;
   kal_uint8 MaxNumRetry;
   kal_uint8 FirstRetryTimeOut;
   kal_uint8 ReregThreshold;
   kal_uint8 NumNAI;
   HlpMipUserProfileT MipUserProfile[HLP_UIM_MAX_PROFILE_NUM];
} HlpUim3GPDMipUserProfileT;

typedef struct
{
   kal_uint8 ActNAIEntryIndex;
   kal_uint8 NumAddActNAI;
   kal_uint8 AddActNaiEntryIndex[HLP_UIM_MAX_MIP_ADD_ACT_NAI_NUM];
} HlpUim3GPDMipStatusT;

typedef struct
{
   kal_uint8 ActNAIEntryIndex;
   kal_uint8 SSLen;
   kal_uint8 SS[32];
} HlpSipPapSSParmsT;

typedef struct
{
   kal_uint8 NumNAI;
   HlpSipPapSSParmsT SipPapSSParms[HLP_UIM_MAX_PROFILE_NUM];
} HlpUim3GPDSipPapSSParmsT;

typedef struct
{
   kal_uint8  NAIEntryIndex;
   kal_uint32 Application;
   kal_uint8  Priority;
   kal_uint8  DataRateMode;
   kal_uint8  DataBearer;
} HlpUserProfileExtParamsT;

typedef struct
{
   kal_uint8 NumNAI;
   HlpUserProfileExtParamsT UppExtParams[HLP_UIM_MAX_PROFILE_NUM];
} HlpUim3GPDUserProfileExtT;

typedef struct
{
   kal_uint16 InitNeighborSolicitDelayTime;
   kal_uint16 SolicitInterval;
   kal_uint16 ReSolicitInterval;
   kal_uint16 MaxSolicitAttempt;
   kal_uint16 MaxReSolicitAttempt;
   kal_uint16 PreRAExpiryReSolicitTime;
   kal_uint8  IidInfo[8];
   kal_uint8  Flags;
} HlpUim3GPDIpv6capT;

typedef struct
{
   kal_uint8 Flags;
   kal_uint8 KeepAliveIdleTimer;
} HlpUim3GPDTcpConfigT;

typedef struct
{
   kal_uint8 DataDormTimer;
   kal_uint8 EpzidTypeInfo;
   kal_uint8 HystActTime;
} HlpUim3GPDDgcT;

typedef struct
{
   kal_uint8 MaxNaiLen;
   kal_uint8 MaxSsLen;
   kal_uint8 AuthAlgo;
} HlpUimHrpdAccessAuthCapT;

typedef struct
{
   kal_uint8 NaiLen;
   kal_uint8 Nai[HLP_MAX_USRID_LEN];
   kal_uint8 AuthAlgo;
} HlpUimHrpdAccessAuthUppT;

typedef struct
{
   /* this field indicates the EFcst, EFust, EFest file be used or not
    * used only for UIM file test critical checking
    * KAL_FALSE, not use the files
    * KAL_TRUE,  use the files
    * default value should be KAL_FALSE
    */
   kal_bool  TurnOnCheck;
   kal_bool  SipEnabled;
   kal_bool  MipEnabled;
   kal_bool  HrpdEnabled;
   kal_bool  Msg3gpdExtEnabled;
   kal_bool  Ipv6Enabled;
   /* EFust, 6F38, byte5.bit3 */
   kal_bool  UstAclEnabled;
   /* EFest, 6F56, byte1.bit3 */
   kal_bool  EstAclEnabled;
} HlpUimServiceTableT;

typedef struct
{
   kal_bool Flag;
   kal_uint16 FileId[2];
   kal_bool IsNeededForCTCard;
} HlpUimFileTableT;

typedef struct
{
  /*-------------card status----------------*/
  kal_uint8                          CardStatus;
  /*-------------card index----------------*/
  sim_interface_enum                 sim_index;
  /*-------------card type-----------------*/
  kal_bool                           is_uicc_card;
  kal_bool                           is_omh_card;
  kal_bool                           is_ct_card;
  /*-------------file read flag-------------*/
  /* read index point to next file index */
  kal_uint8                          ReadIndex;
  kal_bool                           ReadDone;
  /* this flag is ugly! to solve the duplicated 0x6F56 EF ID
   * in RUIM/CSIM, it's EFhrpdcap, in USIM, it's EFest
   * in HLP_UIM_FILE_CHANGED_MSG, if 0x6F56 received, both files are read
   * EFhrpdcap will always be handled before EFest
   * default value is KAL_FALSE, once EFhrpdcap is handled, this flag is set to KAL_TRUE
   * after the whole read procedure is finished, this flag is reset to KAL_FALSE
   */
  kal_bool                           Cur6F56IsUsimFile;

  /*-------------service table--------------*/
  HlpUimServiceTableT            srvtbl;

  /*-------------operation mode-------------*/
  /* EFme3gpdopc */
  kal_uint8                          opc;
  /* EF3gpdopm */
  kal_uint8                          opm;

  /*----------------simpe IP----------------*/
  /* EFsipsp */
  kal_uint8                          sipsp;
  /* EFsipcap */
  HlpUim3GPDSipCapT              sipcap;
  /* EFsipupp */
  HlpUim3GPDSipUserProfileT      sipupp;
  /* EFsippapss */
  HlpUim3GPDSipPapSSParmsT       sippapss;

  /*----------------mobile IP----------------*/
  /* EFmipsp */
  HlpUim3GPDMipStatusT           mipsp;
  /* EFmipcap */
  HlpUim3GPDMipCapT              mipcap;
  /* EFmipupp */
  HlpUim3GPDMipUserProfileT      mipupp;

  /*-------------extension files-------------*/
  /* EFmipflags */
  kal_uint8                          mipflags;
  /* EF3gpduppext */
  HlpUim3GPDUserProfileExtT      uppext;
  /* EFtcpconfig */
  HlpUim3GPDTcpConfigT           tcpcfg;
  /* EFdgc */
  HlpUim3GPDDgcT                 dgc;
  /* EFipv6cap */
  HlpUim3GPDIpv6capT             ipv6cap;

  /*---------HRPD Access Auth files---------*/
  /* EFhrpdcap */
  HlpUimHrpdAccessAuthCapT       hrpdcap;
  /* EFhrpdupp */
  HlpUimHrpdAccessAuthUppT       hrpdupp;
  /* EFimsi */
  IMSIType                       imsi;
  kal_bool                       bUSIMIMSINeedUpdate;
  /* EFad */
  kal_uint8                      MncLen;
} HlpUimFilesT;

typedef void (*hlp_timer_expiry_func)(hlp_timer_enum timer_id);

typedef struct
{
    eventid                  id;
	hlp_timer_enum           timer_id;
    kal_bool                 pending;
    kal_uint32               duration_ms;
    hlp_timer_expiry_func    expiry_func;
}hlp_es_struct;

typedef struct
{
    peer_buff_struct *head;
    peer_buff_struct *tail;
}hlp_sll_ul_queue_struct;

typedef struct
{
    peer_buff_struct *head;
    peer_buff_struct *tail;
    kal_uint8        pdn_id;
}hlp_sll_dl_queue_struct;

/*----------------------------------------------------------------------------
 Global Variable Declarations
----------------------------------------------------------------------------*/
extern kal_bool     PppRenego;

/*----------------------------------------------------------------------------
 Function Declarations
----------------------------------------------------------------------------*/
void HlpConnectionIndMsg(void *MsgDataP, kal_bool atDONetwork);
void Hlp1XMTConnInNullStIndMsg(void *MsgDataP);
void HlpConnectionReleasedIndMsg(void *MsgDataP);
void HlpConnectionFailedIndMsg(void *MsgDataP);
void HlpPppConnectReqMsg(void *MsgDataP);
void HlpPppDisconnectReqMsg(void *MsgDataP);
void HlpPppUpdateReqMsg(void *MsgDataP);
void HlpPppReleaseReqMsg(void *MsgDataP);
void HlpPppStatusMsg(void *MsgDataP);
void HlpUmAppInstance(void * MsgDataPtr);
void HlpPppAnswerReqMsg(void *MsgDataP);
void HlpRlpResetIndMsg(void *MsgDataP);
void HlpFwdDataIndSig(void);
void HlpRevDataIndSig(void);
void HlpRlpRevDataRspMsg(void *MsgDataP);
void HlpRlpIdleIndMsg(void *MsgDataP);
void HlpRlpOpenFailedMsg(void *MsgDataP);
void HlpRlpRevDataRspMsg(void *MsgDataP);
void HlpUpbConnStatusMsg(void *MsgDataP);
void HlpUpbConnReqMsg(void* MsgDataP);
void HlpAiwBeginUdpMsg(void* MsgDataP);
void HlpUpbEndMsg(void* MsgDataP);
void HlpUpbSendDataMsg(void* MsgDataP);
void HlpUpbDormantReq(void *MsgDataP);
void HlpUpbRecvDataRspMsg(void *MsgDataP);
void HlpRmPppBeginMsg(void* MsgDataP);
void HlpRmDisconnectInd(void *MsgDataP);
void HlpRmConnectStatusMsg(void *MsgDataP);
void HlpServiceStatusMsg(void *MsgDataPtr);
void HlpUmPppBeginMsg(void* MsgDataP);
void HlpUmRestartRlpMsg(void* MsgDataP);
void HlpUmDisconnMsg(void* MagDataP);
void HlpDormantReconnectReqMsg(void* MagDataP);
void HlpUmAbortReqMsg(void* MagDataP);
void HlpMipUmPppStatusMsg(void * MsgDataP);
void HlpPktZoneIdMsg(void* MagDataP);
void HlpTimerExpiredMsg(void* MsgDataP);
void HlpTestBrowserConnectMsg(void* MsgDataP);
void HlpTcpbConnReqMsg(void* MsgDataP);
void HlpTcpbConnEndMsg(void* MsgDataP);
void HlpTcpbDataSendReqMsg(void* MsgDataP);
void HlpTcpbDataRecvRspMsg(void *MsgDataP);
void HlpSocketCreateMsg(void *MsgDataP);
void HlpSocketBindMsg(void *MsgDataP);
void HlpSocketConnectMsg(void *MsgDataP);
void HlpSocketCloseMsg(void *MsgDataP);
void HlpSocketSendReqMsg(void *MsgDataP);
void HlpSocketListenMsg(void *MsgDataP);
void HlpSocketOptionMsg(void *MsgDataP);
void HlpSocketShutDownMsg(void *MsgDataP);
void HlpSocketLingerMsg(void *MsgDataP);
void HlpUartReadyMsg(void *MsgDataP);
void HlpMipInit(void);
void HlpMipRrpMsg(void *MsgDataP);
void HlpMipAgentAdvMsg(void *MsgDataP);
void HlpMipUmPppStatusMsg(void *MsgDataP);
void HlpOosaIndMsg(void *MsgDataPtr);
void HlpSystemQueryRspMsg(void* MsgDataPtr);
void HlpSysSelPrefSetMsg(void* MsgDataPtr);
void HlpUmPppReNegotiationMsg(void *MsgDataPtr);
void HlpSetNetworkOrRelayModeMsg(void *MsgDataPtr);
void HlpAlmpConnReleased(void);
void HlpAlmpConnFailed(void);
void HlpXoffRspRcvdMsg(void);
#ifdef KDDI_EXTENSIONS
extern void HlpDORetryTmrExp(void);
#endif
void HlpDormantReqMsg(void);
void HlpValCtaUpdateReqMsg(HlpValCtaUpdateReqMsgT* MsgDataPtr);
void HlpSetHoFlag(kal_uint8 direction);
kal_uint8 HlpGetHoFlag(void);
extern void HlpVoiceCallReleaseIndMsg(void);
#ifdef MTK_DEV_C2K_IRAT
void HlpSetHO21xFlag(kal_bool bHO21xEnabledFlag);
kal_bool HlpGetHO21xFlag(void);
void HlpSetByPassThresholdCheckFlag(kal_bool bNewFlag);
kal_bool HlpGetByPassThresholdCheckFlag(void);
#endif /* MTK_DEV_C2K_IRAT */
void HlpValDMUVSetMsg(void *MsgDataPtr);
void HlpDOInactivityExprMsg(void);
#ifdef MTK_DEV_C2K_IRAT
void HlpSendPppMtu2Val(void);
#endif
HlpDataChRetStatus HlpWrite(RmDataCpBuffDescT *Buff);
HlpDataChRetStatus HlpRead(RmDataCpBuffDescT *Buff);
kal_uint16 GetRevHlpDataSize(void);
kal_uint16 HlpCheckRxReadyStatus(void);
void HlpAccessStreamStart(void);
void HlpGetPPPConnParams(PppConnParamsT *connPtr);

/* System ID Change message function prototypes */
void HlpSidNidChangeIndMsg(void *MsgDataPtr);
void HlpPktZoneIdChangeIndMsg(void *MsgDataPtr);
void HlpSubnetIdChangeIndMsg(void *MsgDataPtr);
void HlpColorCodeIndMsg(void *MsgDataP);

/* Hlpdbm function prototypes */
void HlpDbmHspdSegInitReq(void);
void HlpNvHspdSegDataReadHandler(void);
void HlpParmSetMsg(void *MsgDataPtr);
void hlp_elt_set_parm_msg(ilm_struct* ilm_ptr, HlpParmOperationId ParmId);

void HlpNvSecureDataReadHandler(void);
void HlpParmGetMsg(void *MsgDataPtr);
void hlp_elt_get_parm_msg(ilm_struct* ilm_ptr, HlpParmOperationId ParmId);
void HlpDbmGetEsnMeidRspMsg(void *MsgDataPtr);
void HlpDmuSecureDataChangedMsg(void *MsgDataP);
void HlpPswMDNUpdatedMsg(void *MsgDataPtr);
void HlpSetMipPasswordMsg(void *MsgDataPtr);
kal_uint8 HlpDbmGetMipMode(void);
kal_uint8 HlpDbmGetHaAuthMode(void);
kal_uint8 HlpDbmGetVJCompressionEnabled(void);
void HlpDbmGetPppUmCfg(HlpPppUmCfg_APIStruct *HlpPppUmCfg);
void HlpDbmGetPppRmCfg(HlpPppRmCfg_APIStruct *HlpPppRmCfg);
void HlpDbmGetTcpCfg(HlpTcpCfg_APIStruct *HlpTcpCfg);
kal_bool HlpDbmGetHspdLocked(void);
void HlpNvEHrpdDataReadHandler(void);

void HlpDormancyTimersSetMsg(void *MsgDataPtr);
void HlpDORetryTimersSetMsg(void *MsgDataPtr);

/* Timer expiration function prototypes */
void HlpTimerStartReq(hlp_timer_enum timer_id);
void HlpTimerKillReq(hlp_timer_enum timer_id);
void HlpTimerSetDuration(hlp_timer_enum timer_id, kal_uint32 duration);
void HlpTimerSetPending(hlp_timer_enum timer_id, kal_bool pending);
kal_bool HlpTimerIsActive(hlp_timer_enum timer_id);
kal_bool HlpTimerIsPending(hlp_timer_enum timer_id);
kal_uint32 HlpTimerGetDuration(hlp_timer_enum timer_id);
void WfrFastConnTimeUp(hlp_timer_enum timer_id);
void HlpWfsSysRspTimeup(hlp_timer_enum timer_id);
void HlpWfrUimAuthRspTimeup(hlp_timer_enum timer_id);
void WfrRmConnectionTimeUp(hlp_timer_enum timer_id);
void DataRetryTimeUp(hlp_timer_enum timer_id);
void DoRetryTimeUp(hlp_timer_enum timer_id);
void HlpWaitForIratReleaseTimerExp(hlp_timer_enum timer_id);
void HlpWfrFallBack1XConnectTimeUp(hlp_timer_enum timer_id);
void HlpSetC109LowExp(hlp_timer_enum timer_id);
void HlpProcThrottlingTmrExp(hlp_timer_enum timer_id);
void DormantReconnectBackOffTimerUp(hlp_timer_enum timer_id);
void HlpPppConnectBackOffTimerExp (hlp_timer_enum timer_id);
void HlpFiveMinsTimeOut(hlp_timer_enum timer_id);
void HlpForceCpIdle(hlp_timer_enum timer_id);
void HlpCloseConnAtDO(hlp_timer_enum timer_id);
void HlpMipTimerRrpRegTimeUp(hlp_timer_enum timer_id);
void HlpMipTimerRrpDeregTimeUp(hlp_timer_enum timer_id);
void HlpMipTimerRrqRegTimeUp(hlp_timer_enum timer_id);
void HlpMipTimerAgentAdvTimeUp(hlp_timer_enum timer_id);
void HlpMipTimerLifetimeTimeUp(hlp_timer_enum timer_id);
void HlpIp6TestTmrExp(hlp_timer_enum timer_id);
void natTimerExpire(hlp_timer_enum timer_id);
void HlpPendingRedailA12TmrExp(hlp_timer_enum timer_id);
void HlpSetPendingRedailA12Flag(kal_bool flag);
kal_bool HlpGetPendingRedailA12Flag(void);
void HlpRsvasAbortReqTimeUp(hlp_timer_enum timer_id);

/* Throttling function prototypes */
void HlpThrottSetEnable(kal_bool enable);
kal_bool HlpThrottGetEnable(void);
void HlpThrottSetCurrSys(CamSysTypeT system);
CamSysTypeT HlpThrottGetCurrSys(void);
kal_bool HlpThrottIsActive(CamSysTypeT SystemType);
void HlpThrottLogSysId(CamSysTypeT SystemType);
void HlpThrottInit(void);
void HlpThrottResetAll(void);
void HlpThrottStop(CamSysTypeT SystemType);
void HlpThrottStart(void);

/* IPv6 function prototypes */
#ifdef CBP7_EHRPD
kal_bool EapAkaFailureByNwkRejFlagGet(void);
void EapAkaFailureByNwkRejFlagSet(kal_bool bRejByNetworkNotification);
#endif

void HlpFwdPktDataIndSig( void );

/* PPP free mode support */
void HLPRouteTypeSet(HlpPppRouteTypeE type);
HlpPppRouteTypeE HLPRouteTypeGet(void);
/* TCP/IP filter-mux function prototypes */
void IP_Add_TCP_FilterMux(MuxInfo *Info, kal_uint32 address, kal_uint16 port);
void IP_Delete_TCP_FilterMux(MuxInfo *Info, kal_uint32 address, kal_uint16 port);
kal_bool CheckTcpPacketWithTcpFilterMux(MuxInfo *Info, kal_uint32 address, kal_uint16 port, kal_bool fragmentIpPkt);
void IP_Init_TCP_FilterMux(MuxInfo *Info);

/* UIM function prototypes */
void HlpUimNotifyRegisterMsg(void *MsgDataPtr);
void HlpDbmPowerCycleMsg(void);
void HlpUim3GPDDataUpdate(void);
void HlpUimGet3GPDOpcRspMsg(void *MsgDataPtr);
void HlpUimUpdate3GPDOpcRspMsg(void *MsgDataPtr);
void HlpUimGet3GPDOpmRspMsg(void *MsgDataPtr);
void HlpUimUpdate3GPDOpmRspMsg(void *MsgDataPtr);
void HlpUimGet3GPDSipCapRspMsg(void *MsgDataPtr);
void HlpUimGet3GPDMipCapRspMsg(void *MsgDataPtr);
void HlpUimGet3GPDSipUPPRspMsg(void *MsgDataPtr);
void HlpUimGet3GPDMipUPPRspMsg(void *MsgDataPtr);
void HlpUimGet3GPDSipSPRspMsg(void *MsgDataPtr);
void HlpUimUpdate3GPDSipSPRspMsg(void *MsgDataPtr);
void HlpUimGet3GPDMipSPRspMsg(void *MsgDataPtr);
void HlpUimUpdate3GPDMipSPRspMsg(void *MsgDataPtr);
void HlpUimGet3GPDSipPapSSRspMsg(void *MsgDataPtr);
void HlpUimUpdate3GPDSipPapSSRspMsg(void *MsgDataPtr);
void HlpUimUpdate3GPDImsiRspMsg(void *MsgDataPtr, kal_bool NeedToReadOtherFile);
void HlpUimUpdate3GPDAdRspMsg(void *MsgDataPtr);
kal_uint8 HlpUimGetMipMnHaAuthAlgorithm(void);

/* System ID function prototypes */
void   HlpSetCurrentSidNid(kal_uint16 sid, kal_uint16 nid);
void   HlpSetCurrentPid(kal_uint8 pid);
kal_uint8 *HlpGetCurrentSidPid(void);
void   HlpSetCurrentSubnetId(kal_uint8 *pSubnetId);
kal_uint8 *HlpGetCurrentSubnetId(void);
void   HlpColorCodeIndMsg(void *MsgDataP);
kal_uint16 HlpGetDormancyTimer(kal_bool bForRDUD);
IMSIType HlpGetImsiInfoInUimCntx(void);
kal_uint8 HlpGetMncLenInUimCntx(void);
kal_bool HlpCheckImsiInfoNeedUpdate(void);
void HlpWaitForExtMsg(kal_uint32 expMsgId, ilm_struct *ilm);
#ifdef CBP7_EHRPD
void HlpGetImsiFromUsim(void);
#endif
void HlpSendTchSetupStatusToCss(CssTchSetupStatusT status);
void HlpSendConnStatusMsg2Val(ValWmcConnStatusT connStatus);
void HlpSendPppConnStatusMsg2Val(ValHlpPppConnStatusMsgT *ConnStatus);
void HlpSendPppConnStatusMsg2ValAtc(ValHlpPppConnStatusMsgT *ConnStatus);

void hlp_nvram_read_cnf_handler(local_para_struct *local_para_ptr, peer_buff_struct *peer_buff_ptr);
void hlp_nvram_write_cnf_handler(local_para_struct *local_para_ptr, peer_buff_struct *peer_buff_ptr);
void HlpProcessRevDataFromHIF(void* MsgDataP);
AlmpStateT HlpGetAlmpState(void);
void HlpTcpPacketTagPureAck(kal_uint8 *pIpPacket, socketInfoT *dstSocketPtr);
kal_uint16 PPP_HeaderEncode_CopyFree(kal_uint16 prot, kal_uint8 *data, kal_bool acomp, kal_bool pcomp, kal_uint8 pdn_id);
void HlpHandleDnsQueryNoNwRsp(kal_uint8 *pIpPacket, kal_bool *pToRelPpp);
HlpRecoverFlagT HlpGetRecoverFlag(void);
void HlpSetRecoverFlag(HlpRecoverFlagT value);
kal_bool HlpTransferToLower(char* pStrIn, char* pStrOut, kal_uint32 nLen);
DialingInfoT* HlpCallInfoGet(void);
void HlpSendXonXoffToFcp(kal_bool bXOnOff, StreamType StreamID);
kal_uint8 HlpGetPPPConnParamsCid(void);
kal_bool HlpUimIsUiccCard(void);
kal_bool HlpUimIsOmhCard(void);
void HlpConnectionSuspendCmd(void);
void HlpConnectionResumeCmd(void);
void HlpConnectionDisableCmd(void);
void HlpConnectionResetCmd(void);
void HlpConnectionFallbackCmd(void);

void HlpSetHOEHRPDEnableFlag(kal_bool bEnable);
kal_bool HlpGetHOEHRPDEnableFlag(void);
sim_interface_enum HlpUimGetCurSimIndex(void);
kal_uint16 HlpRmCheckRxReadyStatus(void);

/*****************************************************************************
* End of File
*****************************************************************************/
#endif