#ifdef LWIP_IPNETBUF_SUPPORT
/*====*====*====*====*====*====*====*====*====*====*====*====*====*====*====*

                PLATFORM_SHIM_API.c


GENERAL DESCRIPTION

    This file is for platform shim api.

EXTERNALIZED FUNCTIONS

INITIALIZATION AND SEQUENCING REQUIREMENTS

   Copyright (c) 2011 by Marvell, Incorporated.  All Rights Reserved.
*====*====*====*====*====*====*====*====*====*====*====*====*====*====*====*

*===========================================================================

                        EDIT HISTORY FOR MODULE

  This section contains comments describing changes made to the module.
  Notice that changes are listed in reverse chronological order.


when         who        what, where, why
--------   ------     ----------------------------------------------------------
12/26/12   zhoujin    Created module
===========================================================================*/


/*===========================================================================

                     INCLUDE FILES FOR MODULE

===========================================================================*/

#include "global_types.h"
#include "wan_applet.h"
#include "saremo_RTC.h"
#include "FlashPartition.h"
#include "usb_net.h"
#include "pbuf.h"
#include "netif.h"
#include "FDI_TYPE.h"
#include "lwipopts.h"
#include "cmux.h"
#include "MrvXML.h"
#include "csw_mem.h"
#include "sdio.h"
#include "mp3dec_api.h"
#include "modem_controller.h"
#include "diag_comm_SD.h"
#include "qspi_nor.h"
#include "platform.h"
#include "ningbo.h"
#include "quec_cust_feature.h"

typedef enum
{
    BOOT_FLASH			= 0,
    SAVE_STATE_FLASH	= 1
} FlashBootType_T;

#ifndef CSDAPI_SUPPORT
typedef struct VgFifo8Tag
{
  INT8  *pipe;
  volatile INT16  inptr;
  volatile INT16  outptr;
  INT16 mask;
  INT16 lwm;
  INT16 hwm;
  INT16 byteCount;
} VgFifo8;
#endif

char IMSI[16]={0};
char IMSI_1[16]={0};
const WORD UnitGranularity = 128;

#ifdef CRANE_SD_NOT_SUPPORT
int sdcard_dma_status_for_dma = 0;
unsigned int fat_debug_0;
unsigned int fat_debug_1;
#endif

#ifndef CMUX_ENABLE
/* Mux Mode Type */
cmux_mode_type CmuxMode = CMUX_DISABLE;
#endif

/* Flash Layout Parameters */
FlashLayoutConfInfo FlashLayoutInfo;


/*===========================================================================

            EXTERN DEFINITIONS AND DECLARATIONS FOR MODULE

===========================================================================*/

extern UINT32 SD_BLK_NUM;

/*===========================================================================

                          EXTERN FUNCTION DEFINITIONS

===========================================================================*/
void SulogInit2(void);
void sulog_start_ipc_internal(UINT16 msgOpcode);
void ee_sulog_handler_internal(void);
void SulogOffControlForUsbRemoveInternal(void);
void SulogUsbInitInternal(void);
void BipCmdTaskInitInternal (void);
void get_ntp_time_internal(void);
void cmux_init_internal(void);
void NTP_Init_Internal(void);
void init_atnet_internal(void);
void init_sgLed_internal(void);
void e20_set_timer_flag_internal(void);
void set_sg_led_status_internal(int status);
int test_CameraPreviewInternal(void);
int test_CameraRecordInternal(void);
int test_CameraCaputreInternal(void);
void test_LcdShowImageInternal(UINT8 *isSync);
void test_Logo_LcdShowImageInternal(void);
void test_ASS_LCD_DisplayTextInternal(char * text, int len);
err_t ppp_rx_comm_cb_internal(u8_t *payload, int len);
int cmux_write_internal(int dlci, char *packet, int length);
int atnet_context_is_transport_channel_internal(int channel);
int cmuxGetSvcIdByConnectIdInternal(UINT8 ConnectID);
int SocketRead_timeout_internal(int s, unsigned char* buffer, int len, int timeout_ms);
int SocketWrite_timeout_internal(int s, unsigned char* buffer, int len, int timeout_ms);
extern void _initMESmsInfo(void);

extern int get_pp_flag(void);
extern void set_fix_pp(unsigned char pp);
#ifdef WIFI_FUNCTION_SUPPORT
extern int lega_wlan_get_mac_address(uint8_t *mac_addr);
#endif

/*===========================================================================

                          INTERNAL FUNCTION DEFINITIONS

===========================================================================*/


UINT32 getFixedIP(char *MAC)
{
    return 0;
}


int checkFixedIP(UINT32 IP)
{
    return 0;
}

int SaveCalDataFromMfg(const void *buffer,int element_size, const char *file)
{
    return 0;
}

int woal_uap_do_ioctl(UINT32 cmd, UINT8 *cmd_buf)
{
    return 0;
}

BOOL IsGsmRatForMIFI(void  )
{
	return FALSE;
}

#ifndef ENABLE_CAT1_LG
BOOL IsGsmRatPowerOn(void)
{
	return FALSE;
}
#endif

int ipv4_address_change_trigger(void)
{
	return 0;
}

#ifndef MBIM_FUNCTION
UINT8 IsMbimEnabled(void)
{
    return 0;
}
#endif


void LteConstructSnDataNodeEForMifi(unsigned char cid, unsigned char  *dataAddr, unsigned short dataLen)
{
    return;
}

void UIRefresh_Throughput_Change(void)
{
	return;
}

int embms_data_input(void * data)
{
	return 0;
}

void lte_lwip_free(void* ptr, int size)
{
    return;
}

#ifndef LWIP_NETIF_LTE
void* lte_lwip_malloc(int size, BOOL isQosPacket)
{
    return NULL;
}
#endif


#ifndef YMODEM_EEH_DUMP
int YmodemCfgSet(int type)
{
    return -1;
}
#endif

#ifdef SULOG_DISABLE
unsigned int sulog_file_handle_g = 0;
#endif

#ifdef REMOVE_MBEDTLS

#define MBEDTLS_DES_KEY_SIZE    8

void mbedtls_md5_finish( void *ctx,
                         unsigned char output[16] )
{
    return;
}

void mbedtls_md5_starts( void *ctx )
{
   return;
}

void mbedtls_md5_update( void *ctx,
                         const unsigned char *input,
                         size_t ilen )
{
    return;
}

void mbedtls_ctr_drbg_free( void *ctx )
{
    return;
}

void mbedtls_ctr_drbg_init( void *ctx )
{
    return;
}

int mbedtls_ctr_drbg_random( void *p_rng,
                     unsigned char *output, unsigned int output_len )
{
    return -1;
}

int mbedtls_ctr_drbg_seed( void *ctx,
                   int (*f_entropy)(void *, unsigned char *, unsigned int),
                   void *p_entropy,
                   const unsigned char *custom,
                   unsigned int len )
{
    return -1;
}

void mbedtls_entropy_free( void *ctx )
{
    return;
}

int mbedtls_entropy_func( void *data, unsigned char *output, unsigned int len )
{
    return -1;
}

void mbedtls_entropy_init( void *ctx )
{
    return;
}

int mbedtls_ssl_close_notify( void *ssl )
{
    return -1;
}

void mbedtls_ssl_conf_authmode( void *conf, int authmode )
{
    return;
}

void mbedtls_ssl_conf_dbg( void *conf,
                  void (*f_dbg)(void *, int, const char *, int, const char *),
                  void  *p_dbg )
{
    return;
}

void mbedtls_ssl_conf_rng( void *conf,
                  int (*f_rng)(void *, unsigned char *, size_t),
                  void *p_rng )
{
    return;
}

int mbedtls_ssl_config_defaults( void *conf,
                                 int endpoint, int transport, int preset )
{
    return -1;
}

void mbedtls_ssl_config_free( void *conf )
{
    return;
}

void mbedtls_ssl_init( void *ssl )
{
    return;
}

int mbedtls_ssl_read( void *ssl, unsigned char *buf, unsigned int len )
{
    return -1;
}

void mbedtls_ssl_set_bio( void *ssl,
        void *p_bio,
        void *f_send,
        void *f_recv,
        void *f_recv_timeout )
{
    return;
}

int mbedtls_ssl_setup( void *ssl,
                       const void *conf )
{
    return -1;
}

int mbedtls_ssl_write( void *ssl, const unsigned char *buf, unsigned int len )
{
    return -1;
}

void mbedtls_ssl_config_init( void *conf )
{
    return;
}

void mbedtls_ssl_free( void *ssl )
{
    return;
}

int md_hmac( const void *md_info,
                     const unsigned char *key, unsigned int keylen,
                     const unsigned char *input, unsigned int ilen,
                     unsigned char *output )
{
    return -1;
}

const void *md_info_from_type( int md_type )
{
    return NULL;
}

unsigned int mpi_msb( const void *X )
{
    return 0;
}

int mpi_read_binary( void *X, const unsigned char *buf, unsigned int buflen )
{
    return 0;
}

void sha1_starts( void *ctx )
{
    return ;
}

void sha1_update( void *ctx,
                          const unsigned char *input,
                          unsigned int ilen )
{
    return ;
}

void mbedtls_debug_set_threshold( int threshold )
{
    return;
}

int mbedtls_aes_crypt_cbc( void *ctx,
                    int mode,
                    unsigned int length,
                    unsigned char iv[16],
                    const unsigned char *input,
                    unsigned char *output )
{
    return -1;
}

int mbedtls_aes_setkey_dec( void *ctx, const unsigned char *key,
                    unsigned int keybits )
{
    return -1;
}

int mbedtls_aes_setkey_enc( void *ctx, const unsigned char *key,
                    unsigned int keybits )
{
    return -1;
}

int mbedtls_des3_crypt_cbc( void *ctx,
                     int mode,
                     unsigned int length,
                     unsigned char iv[8],
                     const unsigned char *input,
                     unsigned char *output )
{
    return -1;
}

int mbedtls_des3_set3key_dec( void *ctx,
                      const unsigned char key[MBEDTLS_DES_KEY_SIZE * 3] )
{
    return 0;
}

int mbedtls_des3_set3key_enc( void *ctx,
                      const unsigned char key[MBEDTLS_DES_KEY_SIZE * 3] )
{
    return 0;
}

void mbedtls_sha1_finish( void *ctx,
                          unsigned char output[20] )
{
    return;
}

void mbedtls_sha1_starts( void *ctx )
{
    return;
}

void mbedtls_sha1_update( void *ctx,
                          const unsigned char *input,
                          unsigned int ilen )
{
    return;
}
#endif

#ifdef NO_DIALER
int get_auto_apn_mtu(int simID)
{
    return -1;
}

int get_in_dialer_mt_proc(void)
{
    return 0;
}

void set_in_dialer_mt_proc(int flag)
{
    return;
}

void dialer_task_init(void)
{
    return;
}
 BOOL get_cgdf_save_mode(void)
{
	return FALSE;
}
 
 void set_imsi_changed_flag(UINT32 reqHandle, UINT8 changed)
 {
 	return;
 }


#endif

#ifndef BT_TEST_SUPPORT
void asrbt_main(void)
{
    return;
}
#endif

#ifndef BT_SUPPORT
int bt_wakelock_status(void)
{
    return 0;
}

void appbt_bt_enter_sleep(void)
{
}

void appbt_bt_exit_sleep(void)
{
}

UINT8 GetBTPmLock(void)
{
    return 0;
}
#endif



void td_send_packet(UINT8 *data, UINT32 len,int cid)
{
    return;
}

#if 0
void mvUsbNetSendPacket(UINT8* data, UINT32 len)
{
    return;
}
#endif

#ifndef WIFI_FUNCTION_SUPPORT
int get_wifi_mac(u8_t *wifi_mac)
{
    return 1; /*0: ok; 1: failed.*/
}
#else
int get_wifi_mac(u8_t *wifi_mac)
{
    return lega_wlan_get_mac_address(wifi_mac);
}
#endif

void try_wakeup_host(void)
{
    return;
}

int GetWiFiType(void)
{
	return 0;
}

UINT8 GetWifiStatus(void)
{
    return 0;
}

void OLED_WIFITransferStatusChange(void)
{
    return;
}

int WIFI_Sendto_Wapi(UINT8 *data, UINT32 len){
    return 0;
}

signed long WIFI_Sendto_Wps(UINT8 bss_type, UINT8 *data, UINT32 len){
    return 0;
}

#ifndef WIFI_FUNCTION_SUPPORT
signed long netif_send_to_wifi_uap_nocpy(UINT8 *data, UINT32 len)
{
    return 0;
}

UINT8 sdio_work(void)
{
    return 0;
}

#endif

int uap_packet_free(char *buf)
{
	return 0;
}

UINT32 EraseFlash(UINT32 flash_addr, UINT32 size, FlashBootType_T fbt)
{
	fatal_printf("EraseFlash 0x%x 0x%x\r\n", flash_addr, size);

	spi_nor_do_erase(flash_addr, size, 0);

    return 0;
}

UINT32 ReadFlash(UINT32 flash_addr, UINT32 buffer, UINT32 total_size, FlashBootType_T fbt)
{
	fatal_printf("ReadFlash 0x%x 0x%x\r\n", flash_addr, total_size);

	spi_nor_do_read(flash_addr, buffer, total_size, 0);


    return 0;
}

UINT32 WriteFlash(UINT32 flash_addr, UINT32 buffer, UINT32 total_size, FlashBootType_T fbt)
{
	fatal_printf("WriteFlash 0x%x 0x%x\r\n", flash_addr, total_size);

	spi_nor_do_write(flash_addr, buffer,total_size, 0);

    return 0;
}

FlashLayoutConfInfo *GetFlashLayoutConfig(void)
{
    return &FlashLayoutInfo;
}

void Giga_Enable4BytesMode(void)
{
    return;
}

void Giga_Disable4BytesMode(void)
{
    return;
}

void Rdisk_FlashRead(unsigned int flashaddress, unsigned char *buffer, unsigned int size)
{
    return;
}
#if 0
void SetCfunValue(int value)
{
    return;
}
#endif
void UIRefresh_Operator_Change(void)
{
    return;
}


void watchdog_reset(void)
{
    return;
}

#if 0
UINT8 *mvUsbNetGetMacAddress(void)
{
    return UsbNetMacAddress;
}
#endif

#ifndef PSM_ENABLE

int psm_commit__(void)
{
    return 0;
}

char *psm_get_wrapper(char *mod_name, char *subspace, char *variable)
{
    return NULL;
}

int psm_set_wrapper(char *mod_name, char *subspace, char *variable, char *value)
{
    return 0;
}

#endif

#ifndef CRANE_MCU_DONGLE
signed long dialerResponseToCmux(void *rsp)
{
    return 0;
}

signed long dialerReportNokToCmux(signed long conNum)
{
    return 0;
}
#endif

#ifdef CRANE_SD_NOT_SUPPORT
#include "FDI_ERR.h"
#include "crossPlatformSW.h"

int FAT_fclose(unsigned int stream)
{
    return 0;
}

unsigned int FAT_fopen(const char *filename_ptr, const char *mode)
{
    return 0;
}

size_t FAT_fread(void *buffer_ptr, size_t element_size, size_t count, unsigned int stream)
{
    return 0;
}

unsigned int FAT_fwrite(const void *buffer_ptr,size_t element_size,size_t count,unsigned int stream)
{
    return 0;
}

int FAT_remove(const char *filename_ptr)
{
    return -1;
}

int get_log_sd_unused(void)
{
    return -1;
}

//Those three funcs are dir operation
int FAT_MakeDir(char *dir_name, unsigned int mode)
{
	return -1;
}

BOOL FAT_findfileclose(unsigned int handle)
{
	return FALSE;
}

unsigned int FAT_findfirst(const char *filename_ptr, LPFAT32FILEINFO fileinfo_ptr)
{
    return 0;
}


int FAT_findnext(unsigned int handle, LPFAT32FILEINFO fileinfo_ptr)
{
    return -1;
}


void sdcard_need_format(void)
{
    return;
}

void sdcard_not_need_format(void)
{
    return;
}

ERR_CODE FAT_Format(char *vol)
{
    return 0;
}
int FAT_GetCurrentDir(char *dir_name, unsigned int max_len)
{
    return 0;
}

int FAT_GetFSInfo(char *pszDevName, FS_INFO* psFSInfo)
{
    return 0;
}

unsigned int FAT_GetFileSize(unsigned int stream)
{
    return 0;
}

BOOL FAT_IsFormatted(char *vol)
{
    return 0;
}


int FAT_MakeDir_M(char *dir_name, unsigned int mode)
{
    return 0;
}

UINT32 FAT_Getfree(char *path)
{
    return 0;
}


int FAT_RemoveDir(char *dir_name)
{
    return 0;
}

int FAT_SetCurrentDir(char *dir_name)
{
    return 0;
}

int FAT_eof(unsigned int stream)
{
    return 0;
}

int FAT_fseek(unsigned int stream, long offset, int wherefrom)
{
    return 0;
}

int FAT_rename(const char *oldname_ptr, const char *newname_ptr)
{
    return 0;
}


#ifndef ADAPT_FRAMEWORK_BUILD
void set_sdcard_power_gpio(UINT8 num)
{
    return;
}
#endif


#endif

#ifndef MP3_DECODE
int mp3Start(const char *file_name)
{
    return -1;
}
#endif

#ifdef NO_OPENSSL
int ssl_read( void *ssl, unsigned char *buf, int len )
{
    return -1;
}

int ssl_write( void *ssl, const unsigned char *buf, int len )
{
    return -1;
}

void md5_finish( void *ctx, unsigned char output[16] )
{
    return;
}

void md5_starts( void *ctx )
{
    return;
}

void md5_update( void *ctx, const unsigned char *input, int ilen )
{
    return;
}

int entropy_func( void *data, unsigned char *output, int len )
{
    return -1;
}


int ssl_close_notify( void *ssl )
{
    return -1;
}

int ssl_init( void *ssl )
{
    return -1;
}

void ssl_free( void *ssl )
{
    return;
}

void entropy_init( void *ctx )
{
    return;
}

int ctr_drbg_init( void *ctx,
                   int (*f_entropy)(void *, unsigned char *, int),
                   void *p_entropy,
                   const unsigned char *custom,
                   int len )
{
    return -1;
}

int ctr_drbg_random( void *p_rng, unsigned char *output, int output_len )
{
    return -1;
}

void ssl_set_rng( void *ssl,
                  int (*f_rng)(void *, unsigned char *, size_t),
                  void *p_rng )
{
    return;
}

void ssl_set_dbg( void *ssl,
                  void (*f_dbg)(void *, int, const char *),
                  void  *p_dbg )
{
    return;
}


void ssl_set_bio( void *ssl,
            int (*f_recv)(void *, unsigned char *, size_t), void *p_recv,
            int (*f_send)(void *, const unsigned char *, size_t), void *p_send )
{
    return;
}

void ssl_set_endpoint( void *ssl, int endpoint )
{
    return;
}


void ssl_set_authmode( void *ssl, int authmode )
{
    return;
}
#endif

#ifdef NO_MRD
int  AtMrdMips(void *reqSig,void *pCnfParas)
{
    return 0;
}

int  AtMrdImei(void *reqSig,void *pCnfParas)
{
    return 0;
}

int  AtMrdCdf(void *reqSig,void *pCnfParas)
{
   return 0;
}

void set_mrd_production_mode(UINT32 val)
{
	return;
}

void set_calib_production_mode(UINT32 val)
{
    return;
}

UINT32 InProduction_Mode(void)
{
    return 0;
}

void BtIDInit(unsigned long *ddrBuffaddr)
{
    return;
}
#endif

#ifdef ENABLE_WIFI_SCAN
extern void _processWifiHotspotInfoInd(const void *paras);

void processWifiHotspotInfoInd(const void *paras)
{

#ifndef MIN_SYS
    if(!IsMiniSystem()) {
        _processWifiHotspotInfoInd(paras);
    }
#endif

	return;
}
#endif


#ifdef NO_AUDIO
typedef void (*audioGsmStartVoicePath_t)(void);
typedef void (*audioGsmStopVoicePath_t)(void);
//#ifdef MACRO_FOR_LWG
typedef void (*audioGsmGetVocoderTypeRate_t)(unsigned short *vocoderType, unsigned short *vocoderRate);
//#endif
typedef BOOL  (*audioGsmGetDtxSupport_t)(void);
typedef void* (*audioGsmGetTxBuffer_t)(void);
typedef void  (*audioGsmSetAmrToc_t)(unsigned short);
typedef void  (*audioGsmSetAmrSidTypeInd_t)(unsigned short);
typedef void  (*audioGsmSetEncoderFlags_t)(unsigned short);
typedef void  (*audioGsmSetDecoderSidInd_t)(unsigned short);

#if 0
void audioPhase1Init(void)
{
    return;
}
#endif 

void audioBindGsmGetDtxSupport(audioGsmGetDtxSupport_t audioGsmGetDtxSupport)
{
    return;
}

void audioBindGsmGetTxBuffer(audioGsmGetTxBuffer_t audioGsmGetTxBuffer)
{
    return;
}

void audioBindGsmGetVocoderTypeRate(audioGsmGetVocoderTypeRate_t audioGsmGetVocoderTypeRate)
{
    return;
}

void audioBindGsmSetAmrSidTypeInd(audioGsmSetAmrSidTypeInd_t audioGsmSetAmrSidTypeInd)
{
    return;
}

void audioBindGsmSetAmrToc(audioGsmSetAmrToc_t audioGsmSetAmrToc)
{
    return;
}

void audioBindGsmSetDecoderSidInd(audioGsmSetDecoderSidInd_t audioGsmSetDecoderSidInd)
{
    return;
}

void audioBindGsmSetEncoderFlags(audioGsmSetEncoderFlags_t audioGsmSetEncoderFlags)
{
    return;
}

void audioBindGsmStartVoicePath(audioGsmStartVoicePath_t audioGsmStartVoicePath)
{
    return;
}

void audioBindGsmStopVoicePath(audioGsmStopVoicePath_t audioGsmStopVoicePath)
{
    return;
}

int AudioHAL_AifDrain(void)
{
    return 0;
}

int AudioHAL_AifPlayStream(void *playedStream)
{
    return 0;
}

void AudioHAL_AifStopPlay(void)
{
    return;
}

int AudioHAL_SetResBufCnt(unsigned int bufCnt)
{
    return 0;
}

int AudioHAL_AifPause(BOOL pause)
{
    return 0;
}

BOOL CraneCodecADCOnOff(BOOL OnOff)
{
    return FALSE;
}
#ifdef QUECTEL_PROJECT_CUST
void ECallEimSet(const char* msd, int mode)
{
    return;
}

void audioPhase2Init(void)
{
    return;
}
void audioPhase1Init(void)
{
    return;
}
#endif
typedef void (*AUDIOHAL_HeadsetReport_T) (UINT32 plug, UINT32 type, UINT32 event);

void AudioHAL_AifBindHeadsetDetectionCB(AUDIOHAL_HeadsetReport_T cb)
{
    return;
}

void AudioHAL_AifGetHeadsetInfo(UINT32* plug, UINT32* type)
{
    return;
}

UINT32 AudioHAL_AifGetVolume(void)
{
    return 0;
}

void AudioHAL_AifHeadsetDetection(BOOL onoff)
{
    return;
}

void AudioHAL_set_close_delay(unsigned int cnt)
{
    return;
}




#endif

UINT8 Is_dedicateAPN(char cid)
{
	if( cid > 8)
		return 1;
	else
		return 0;
}

BOOL psNvmCheckAPNInfo(char *input_apn,	UINT8 ip_type)
{
	return FALSE;
}

int get_hwver_type(void)
{
	return 0;
}

UINT8 get_atcmdsrv_cfun4_flag(void)
{
	return 0;
}

UINT8 clear_atcmdsrv_cfun4_flag(void)
{
    return 0;
}

unsigned char Update_RTC_Time(void)
{
    return 0;
}

void UIRefresh_PDPState_Change(void)
{
    return;
}

void UIRefresh_Modem_Change(void)
{
    return;
}

void Get_backtime_frompsm(void)
{
    return;
}

void GetCurrentCompTime(TIME *con_time)
{
    return;
}

BOOL GetBIPEnableFlag(void)
{
#ifdef BIP_FUNC_SUPPORT
extern int BIPCfgGet(void);
    if (BIPCfgGet())
	    return TRUE;
    else
        return FALSE;
#else
	return FALSE;
#endif
}
UINT32 usb_net_tx(UINT32 *txPtr, UINT32 length)
{
    return 0;
}
// dummy function for dongle compile
UINT32 usb_net_rx(void *rxPtr, UINT32 maxSize)
{
    return 0;
}

#if 0
int getPSNwReg(void)
{
    return 0;
}
#endif

#if 0
int usbnet_enter_directip(int *ipaddr, int *subnet_mask, int *gwaddr, int *dns1_addr, int *dns2_addr)
{
    return 0;
}
#endif

UINT32 usb_net_init(UsbNetRxDoneCallbackFunc Func)
{
	return 1;
}


BOOL CheckIf32MNOR( void )
{
    return FALSE;
}

BOOL PlatformSpiNorEnable(void)
{
    return FALSE;
}

BOOL isAutoApn(void)
{
	return FALSE;
}

#ifndef CRANE_MCU_DONGLE
int is_E20_module_type(void)
{
	return FALSE;
}
#endif

struct tm GetLocalTime()
{
	struct tm time = {0};

	return time;
}


int get_download_flag_for_tigx(void)
{
	return 0;
}

char get_network_mode(void)
{
	return 5; //CI_DEV_NW_LTE_MODE;
}

int get_uart2_baudrate_for_tigx(void)
{
	return -1;
}

int set_download_flag_for_tigx(int flag)
{
	return 0;
}

int set_uart2_baudrate_for_tigx(unsigned int rate)
{
	return 0;
}

void set_uart_selfadapt(void)
{
	return;
}

#ifdef CRANE_MCU_DONGLE
UINT32 FdvBlockSize = 128*1024; /*block size*/
UINT16 FdvBlockCount= 10; /*numbers of block*/


ERR_CODE FDI_SizeAvailable (WORD frag_size, DWORD_PTR total_size)
{
	*total_size = 0x20000;
	return ERR_NONE;
}

ERR_CODE FDI_SpaceUsed(WORD identifier, BYTE type, DWORD_PTR spaceused)
{
	*spaceused = 0;
	return ERR_NONE;
}

VOID FDI_TaskDelayTicks(UNSIGNED numTicks)
{
	return;
}

#endif

#ifndef WEBUI_SUPPORT
void wan_add_device(DeviceNode *device, int deviceType)
{
    if(device)
        free(device);
	return;
}

void wan_delete_device(DeviceNode *device, int deviceType)
{
    if(device)
        free(device);
	return;
}

int is_aes_cipher()
{
	return 0;
}
#endif

#ifdef CRANE_MCU_DONGLE

#if defined(FOTA_RS_FEATURE) || defined(FOTA_GS_FEATURE)
int NVMFileNameMatch(const char *src, const char *dest)
{
    return 0;
}
#else
UINT32 flush_time_check(UINT32 val)
{
    return 0;
}

void nvm_cache_flush_all(void)
{
    return;
}
void nvm_flush_ps_idle_cnf(BOOL flag)
{
    return;
}

void nvm_flush_ps_resume_ind(void)
{
    return;
}

void RamBlockSyncOpWriteTrigger(UINT32 type, UINT32 current, UINT32 len)
{
    return;
}

UINT32 get_d2_nvm_flush(void)
{
    return 0;
}

void disable_d2_nvm_flush(void)
{
    return;
}

void enable_d2_nvm_flush(void)
{
    return;
}

void qspi_flush_in_time(UINT32 time)
{
    return;
}
void record_flush_write(UINT32 start, UINT32 len)
{
    return;
}

#endif
#endif


void SulogInit(void)
{
#ifndef SULOG_DISABLE
#ifndef MIN_SYS
    if(!IsMiniSystem())
    {
        SulogInit2();
    }
#endif
#endif
}

void sulog_start_ipc(UINT16 msgOpcode)
{
#ifndef SULOG_DISABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        sulog_start_ipc_internal(msgOpcode);
    }
#endif
#endif
}

void ee_sulog_handler(void)
{
#ifndef SULOG_DISABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        ee_sulog_handler_internal();
    }
#endif

#endif

    return;
}

void SulogOffControlForUsbRemove(void)
{
#ifndef SULOG_DISABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        SulogOffControlForUsbRemoveInternal();
    }
#endif
#endif

    return;
}

void SulogUsbInit(void)
{
#ifndef SULOG_DISABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        #ifdef QUEC_USB_ENABLE
        extern unsigned char quec_sulog_get_status(void);
        if(quec_sulog_get_status())
        #endif
        SulogUsbInitInternal();
    }
#endif
#endif

    return;
}

/*************************************************************************/
/*                                                                       */
/* FUNCTION                                                              */
/*                                                                       */
/*      cmux_init                                                        */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*      The function intializes cmux related variables and task.         */
/*                                                                       */
/* CALLED BY                                                             */
/*                                                                       */
/*      Application                                                      */
/*                                                                       */
/* CALLS                                                                 */
/*                                                                       */
/*      Application                         The application function     */
/*                                                                       */
/* INPUTS                                                                */
/*                                                                       */
/*      None                                N/A                          */
/*                                                                       */
/* OUTPUTS                                                               */
/*                                                                       */
/*      None                                N/A                          */
/*                                                                       */
/*************************************************************************/
void cmux_init(void)
{
#ifdef CMUX_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        cmux_init_internal();
    }
#endif
#endif
}

int cmux_write(int dlci, char *packet, int length)
{
#ifdef CMUX_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return cmux_write_internal(dlci, packet, length);
    }
#endif
#endif
    return -1;
}

void cmux_startup(muxparameter * par)
{
#ifdef CMUX_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        cmux_startup_internal(par);
    }
#endif
#endif
    return;
}

/*************************************************************************/
/*                                                                       */
/* FUNCTION                                                              */
/*                                                                       */
/*      modem_init                                                       */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*      The function intializes modem route.                             */
/*                                                                       */
/* CALLED BY                                                             */
/*                                                                       */
/*      Application                                                      */
/*                                                                       */
/* CALLS                                                                 */
/*                                                                       */
/*      Application                         The application function     */
/*                                                                       */
/* INPUTS                                                                */
/*                                                                       */
/*      None                                N/A                          */
/*                                                                       */
/* OUTPUTS                                                               */
/*                                                                       */
/*      None                                N/A                          */
/*                                                                       */
/*************************************************************************/
void modem_init(void)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS
     if(!IsMiniSystem())
     {
        modem_init_internal();
     }
#endif
#endif
}

/*************************************************************************/
/*                                                                       */
/* FUNCTION                                                              */
/*                                                                       */
/*      send_data_to_modem_router                                        */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*      The function send data to modem router.                          */
/*                                                                       */
/* CALLED BY                                                             */
/*                                                                       */
/*      Application                                                      */
/*                                                                       */
/* CALLS                                                                 */
/*                                                                       */
/*      Application                         The application function     */
/*                                                                       */
/* INPUTS                                                                */
/*                                                                       */
/*      None                                N/A                          */
/*                                                                       */
/* OUTPUTS                                                               */
/*                                                                       */
/*      None                                N/A                          */
/*                                                                       */
/*************************************************************************/
void send_data_to_modem_router(char *data, int len, int atp_index, int from)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS
     if(!IsMiniSystem())
     {
        send_data_to_modem_router_internal(data, len, atp_index, from);
     }
#endif
#endif
}


/*************************************************************************/
/*                                                                       */
/* FUNCTION                                                              */
/*                                                                       */
/*      ppp_enable                                                       */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*      The function get PPP enable flag.                                */
/*                                                                       */
/* CALLED BY                                                             */
/*                                                                       */
/*      Application                                                      */
/*                                                                       */
/* CALLS                                                                 */
/*                                                                       */
/*      Application                         The application function     */
/*                                                                       */
/* INPUTS                                                                */
/*                                                                       */
/*      None                                N/A                          */
/*                                                                       */
/* OUTPUTS                                                               */
/*                                                                       */
/*      None                                N/A                          */
/*                                                                       */
/*************************************************************************/
BOOL ppp_enable(void)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS
    if(!IsMiniSystem())
    {
        return TRUE;
    }
#endif
#endif
    return FALSE;
}

/*************************************************************************/
/*                                                                       */
/* FUNCTION                                                              */
/*                                                                       */
/*      ppp_rx_comm_cb                                                   */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*      The function is cb for comm to send data.                        */
/*                                                                       */
/* CALLED BY                                                             */
/*                                                                       */
/*      Application                                                      */
/*                                                                       */
/* CALLS                                                                 */
/*                                                                       */
/*      Application                         The application function     */
/*                                                                       */
/* INPUTS                                                                */
/*                                                                       */
/*      None                                N/A                          */
/*                                                                       */
/* OUTPUTS                                                               */
/*                                                                       */
/*      None                                N/A                          */
/*                                                                       */
/*************************************************************************/
err_t ppp_rx_comm_cb(UINT8 *payload, int len)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS
    if(!IsMiniSystem())
    {
        return ppp_rx_comm_cb_internal(payload, len);
    }
#endif
#endif

    return 0;
}

/*************************************************************************/
/*                                                                       */
/* FUNCTION                                                              */
/*                                                                       */
/*      get_ppp_cid                                                      */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*      The function get ppp cid.                                        */
/*                                                                       */
/* CALLED BY                                                             */
/*                                                                       */
/*      Application                                                      */
/*                                                                       */
/* CALLS                                                                 */
/*                                                                       */
/*      Application                         The application function     */
/*                                                                       */
/* INPUTS                                                                */
/*                                                                       */
/*      None                                N/A                          */
/*                                                                       */
/* OUTPUTS                                                               */
/*                                                                       */
/*      None                                N/A                          */
/*                                                                       */
/*************************************************************************/
UINT8 get_ppp_cid(void)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS
    if(!IsMiniSystem())
    {
        return get_ppp_cid_internal();
    }
#endif
#endif
	return 0xFF;
}

int process_ppp_atd(int atp_index, char *dial_string)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return process_ppp_atd_internal(atp_index, dial_string);
    }
#endif
#endif
	return -1;
}

void modem_update_reg_option( int atp_index, int option)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        modem_update_reg_option_internal(atp_index, option);
    }
#endif
#endif

    return;
}

BOOL ppp_get_connect_flag(UINT8 cid)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return ppp_get_connect_flag_internal(cid);
    }
#endif
#endif
    return 0;
}

void ppp_process_data_nok(UINT8 cid, BOOL force)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        ppp_process_data_nok_internal(cid, force);
    }
#endif
#endif

    return;
}

void handle_dial(int atp_index)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        handle_dial_internal(atp_index);
    }
#endif
#endif
    return;
}

int get_cgreg_status_rsp(int atp_index, char *rsp_buf, int type)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return get_cgreg_status_rsp_internal(atp_index, rsp_buf, type);
    }
#endif
#endif
    return -1;
}

void ppp_clear_use_eps_apn(UINT32 atp_index)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        ppp_clear_use_eps_apn_internal(atp_index);
    }
#endif
#endif

    return;
}

void ppp_store_configure_params(int atp_index, int cid, char *apn,  int ip_type)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        ppp_store_configure_params_internal(atp_index, cid, apn, ip_type);
    }
#endif
#endif

    return;
}

BOOL need_ppp_process_at_response(int atp_index)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return need_ppp_process_at_response_internal(atp_index);
    }
#endif
#endif
	return 0;
}

void modem_channel_buffer_reset(void)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        modem_channel_buffer_reset_internal();
    }
#endif
#endif
    return;
}

BOOL need_ppp_process_ato_request(int atp_index)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return need_ppp_process_ato_request_internal(atp_index);
    }
#endif
#endif
    return 0;
}

int process_ppp_ato(int atp_index)
{
#ifdef PPP_ENABLE
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return process_ppp_ato_internal(atp_index);
    }
#endif
#endif
    return 0;
}


void BipCmdTaskInit (void)
{
#ifdef BIP_FUNC_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        if (GetBIPEnableFlag())
            BipCmdTaskInitInternal();
    }
#endif
#endif
    return;
}

void get_ntp_time(void)
{
#ifdef NTP
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        #ifndef QUECTEL_PROJECT_CUST /*关闭默认的系统ntp同步*/
        get_ntp_time_internal();
        #endif
    }
#endif
#endif

    return;
}

void NTP_Init(void)
{
#ifdef NTP
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        #ifdef QUEC_GNSS_NTP
        NTP_Init_Internal();
        #endif
    }
#endif
#endif

    return;
}


void init_atnet(void)
{
#ifndef NO_AT_NET
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        init_atnet_internal();
    }
#endif
#endif
    return;
}

void init_sgLed(void)
{
#ifndef NO_AT_NET
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        init_sgLed_internal();
    }
#endif
#endif

    return;
}

int atnet_context_is_transport_channel(int channel)
{
#ifndef NO_AT_NET
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return atnet_context_is_transport_channel_internal(channel);
    }
#endif
#endif
    return 0;
}

int cmuxGetSvcIdByConnectId(UINT8 ConnectID)
{
#ifndef NO_AT_NET
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return cmuxGetSvcIdByConnectIdInternal(ConnectID);
    }
#endif
#endif
	return 6;
}

void e20_set_timer_flag(void)
{
#ifndef NO_AT_NET
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        e20_set_timer_flag_internal();
    }
#endif
#endif

    return;
}

void set_sg_led_status(int status)
{
#ifndef NO_AT_NET
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        set_sg_led_status_internal(status);
    }
#endif
#endif

    return;
}

#if 0
int SocketRead_timeout(int s, unsigned char* buffer, int len, int timeout_ms)
{
#ifndef NO_PAHO_MQTT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return SocketRead_timeout_internal(s, buffer, len, timeout_ms);
    }
#endif
#endif

    return -1;
}

int SocketWrite_timeout(int s, unsigned char* buffer, int len, int timeout_ms)
{
#ifndef NO_PAHO_MQTT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return SocketWrite_timeout_internal(s, buffer, len, timeout_ms);
    }
#endif
#endif
    return -1;
}
#endif

void MrvDeleteAttribute(MrvXMLAttribute *pEntry)
{
#ifndef NO_XML
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        MrvDeleteAttributeInternal(pEntry);
    }
#endif
#endif
    return;
}

MrvXMLElement * MrvEnumElements(MrvXMLElement *pEntry, int *pnIndex)
{
#ifndef NO_XML
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return MrvEnumElementsInternal(pEntry, pnIndex);
    }
#endif
#endif
    return NULL;
}

void MrvDeleteRoot(MrvXMLElement * pElement)
{
#ifndef NO_XML
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        MrvDeleteRootInternal(pElement);
    }
#endif
#endif

    return;
}

MrvXMLElement * MrvFindElement(MrvXMLElement *pEntry, MRV_LPCTSTR lpszPath)
{
#ifndef NO_XML
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return MrvFindElementInternal(pEntry, lpszPath);
    }
#endif
#endif

    return NULL;
}

MrvXMLText *MrvFindOnlyText(MrvXMLElement * pEntry)
{
#ifndef NO_XML
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return MrvFindOnlyTextInternal(pEntry);
    }
#endif
#endif

    return NULL;
}

MrvXMLElement * MrvParseXML(MRV_LPCTSTR lpszXML, MrvXMLResults *pResults)
{
#ifndef NO_XML
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return MrvParseXMLInternal(lpszXML, pResults);
    }
#endif
#endif
    return NULL;
}

MrvXMLNode * MrvEnumNodes(MrvXMLElement *pEntry, int *pnIndex)
{
#ifndef NO_XML
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return MrvEnumNodesInternal(pEntry, pnIndex);
    }
#endif
#endif

    return NULL;
}

MrvXMLAttribute * MrvFindAttribute(MrvXMLElement *pEntry, MRV_LPCTSTR lpszAttrib)
{
#ifndef NO_XML
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return MrvFindAttributeInternal(pEntry, lpszAttrib);
    }
#endif
#endif

    return NULL;
}

/**
 *  @brief: This function initialize SDIO bus driver.
 *
 *  @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
 */
int sdcard_init(void)
{
#ifndef CRANE_SD_NOT_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return sdcard_init_internal();
    }
#endif
#endif
    return 0;
}

#pragma arm section code="SDCARD_READY"
BOOL sdcard_is_ready(void)
{
#ifndef CRANE_SD_NOT_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return sdcard_is_ready_internal();
    }
#endif
#endif
    return FALSE;
}
#pragma arm section code

int eeSDDump_status_get(void)
{
#ifndef CRANE_SD_NOT_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return eeSDDump_status_get_internal();
    }
#endif
#endif

    return 0;
}

void eeSDDumpPrepare(void)
{
#ifndef CRANE_SD_NOT_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        eeSDDumpPrepareInternal();
    }
#endif
#endif

    return;
}

BOOL sdcard_transmit_status(void)
{
#ifndef CRANE_SD_NOT_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return sdcard_transmit_status_internal();
    }
#endif
#endif
    return FALSE;
}

UINT32 sdcard_get_blknum(void)
{
#ifndef CRANE_SD_NOT_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return SD_BLK_NUM;
    }
#endif
#endif

	return 0;
}


UINT32 sdcard_read_multiblks(UINT32 base, UINT32 buffer, UINT32 loop, UINT32 blk_cnt)
{
#ifndef CRANE_SD_NOT_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return sdcard_read_multiblks_internal(base, buffer, loop, blk_cnt);
    }
#endif
#endif
    return 0;
}

UINT32 sdcard_read_singleblk(UINT32 base, UINT32 buffer, UINT32 loop)
{
#ifndef CRANE_SD_NOT_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return sdcard_read_singleblk_internal(base, buffer, loop);
    }
#endif
#endif
    return 0;
}

UINT32 sdcard_write_multiblks(UINT32 base, UINT32 buffer, UINT32 loop, UINT32 blk_cnt)
{
#ifndef CRANE_SD_NOT_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return sdcard_write_multiblks_internal(base, buffer, loop, blk_cnt);
    }
#endif
#endif
    return 0;
}

UINT32 sdcard_write_singleblk(UINT32 base, UINT32 buffer, UINT32 loop)
{
#ifndef CRANE_SD_NOT_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return sdcard_write_singleblk_internal(base, buffer, loop);
    }
#endif
#endif
    return 0;
}

BOOL SDWork(void)
{
#ifndef CRANE_SD_NOT_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        if(TRUE == diagCommSdLogEnable())
        {
            return TRUE;
        }
        else
        {
            return FALSE;
        }
    }
#endif
#endif
    return FALSE;
}

void SulogSDMakeDir(void)
{
#ifndef CRANE_SD_NOT_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        SulogSDMakeDirInternal();
    }
#endif
#endif
    return;
}

int sdcard_fat_is_ok(void)
{
#ifndef CRANE_SD_NOT_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
        return sdcard_fat_is_ok_internal();
#endif
#endif
    return 0;
}


int is_ims_cid(int simid, int cid,char *apn)
{
#ifdef VOLTE_ENABLE
    extern int _is_ims_cid(int simid, int cid,char *apn);
#ifndef MIN_SYS
    if(!IsMiniSystem())
    {
        return _is_ims_cid(simid, cid,apn);
    }
#endif
#endif
    return 0;
}

int get_ims_at_channel(int sim_id)
{
#ifdef VOLTE_ENABLE
    extern int ims_get_at_channel(int sim_id);
#ifndef MIN_SYS
    if(!IsMiniSystem())
    {
        return ims_get_at_channel(sim_id);
    }
#endif
#endif
    return 0;
}
/*
void keypad_init(void)
{
#ifdef CRANE_KEYPAD_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        keypad_init_internal();
    }
#endif
#endif
}

int test_CameraPreview(void)
{
#ifdef CRANE_CAMERA_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return test_CameraPreviewInternal();
    }
#endif
#endif
    return 0;
}

int test_CameraRecord(void)
{
#ifdef CRANE_CAMERA_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return test_CameraRecordInternal();
    }
#endif
#endif
    return 0;
}

int test_CameraCaputre(void)
{
#ifdef CRANE_CAMERA_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return test_CameraCaputreInternal();
    }
#endif
#endif
    return 0;
}

void test_LcdShowImage(UINT8 *isSync)
{
#ifdef CRANE_LCD_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return test_LcdShowImageInternal(isSync);
    }
#endif
#endif
    return;

}

void test_Logo_LcdShowImage(void)
{
#ifdef CRANE_LCD_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return test_Logo_LcdShowImageInternal();
    }
#endif
#endif
    return;

}

void test_ASS_LCD_DisplayText(char * text, int len)
{
#ifdef CRANE_LCD_SUPPORT
#ifndef MIN_SYS

    if(!IsMiniSystem())
    {
        return test_ASS_LCD_DisplayTextInternal(text,len);
    }
#endif
#endif
    return;

}
*/

void initMESmsInfo(void)
{
#ifndef MIN_SYS
#ifndef REMOVE_SMS
    if(!IsMiniSystem())
    {
        _initMESmsInfo();
    }
#endif
#endif

    return;

}

void set_pp_for_test(void)
{
#ifndef MIN_SYS
    if(!IsMiniSystem()) {
        if (get_pp_flag())
           set_fix_pp(5);
    }
#endif       
}


#ifdef ADAPT_FRAMEWORK_BUILD
void setUartDevType(UART_DEV_TYPE type)
{

}

//ICAT EXPORTED FUNCTION - HW_PLAT,utilities,UARTTOUART
void set_uart_dev_uart(void)
{
	//setUartDevType(UART_DEV_UART);
}

//ICAT EXPORTED FUNCTION - HW_PLAT,utilities,UARTTODIAG
void set_uart_dev_diag(void)
{
	//setUartDevType(UART_DEV_DIAG);
}


BOOL is_uart_to_uart(void)
{
	//if(uart_output_dev==UART_DEV_UART)
		return TRUE;
	//else
	//	return FALSE;
}


BOOL getUSBConnectStatus(void)
{
    if(*(volatile unsigned long*)0xD428287C & 1 << 15)
        return TRUE;
    else
        return FALSE;
}


//ICAT EXPORTED FUNCTION - SW_PLAT,NVM,FDI_Factory_Reset
void FDI_Factory_Reset(void)
{
}
#define MAX_FILTER_FILE_NUM	4

#ifdef MMI_INTERFACE
const char filename_filter[MAX_FILTER_FILE_NUM][64]={"vdisk.bin",'\0','\0','\0'};
#else
const char filename_filter[MAX_FILTER_FILE_NUM][64]={'\0','\0','\0','\0'};
#endif



BOOL BacklightStatusBeforeSilentReset = FALSE; //Used to inform to UI whether the backlight was on before silent reset.


BOOL GetBacklightStatusBeforeReset(void)
{
    return BacklightStatusBeforeSilentReset;
}

void set_platform_version(char * version)
{
    return;
}

void set_sdcard_power_gpio(UINT8 num)
{
    return;
}



#endif

#if defined(NOT_SUPPORT_PM813)
#include "pmic_battery.h"
#include "ningbo.h"
#include "pmic_charger.h"

void Ningbo_PowerSave_Config(void)
{
    return;
}

int NingboRead( Ningbo_Reg_Type ningbo_reg_type, unsigned char reg, unsigned char *value )
{
    return 0;
}

int NingboWrite( Ningbo_Reg_Type ningbo_reg_type, unsigned char reg, unsigned char value )
{
    return 0;
}

void Ningbo_INT_CALLBACK_REGISTER(NINGBO_INTC intc, PmicCallback isr)
{
    return;
}

void Ningbo_INT_ENABLE(NINGBO_INTC intc)
{
    return;
}


void NingboKeypadBackLightDisable(void)
{
    return;
}

void NingboKeypadBackLightEnable(void)
{
    return;
}

void NingboLcdBackLightCtrl(UINT8 level) 
{
    return;
}


void NingboLcdBackLightDisable(void)
{
    return;
}


void NingboLcdBackLightEnable(void)
{
    return;
}


void NingboTorchBackLightCtrl(UINT8 level)
{
    return;
}


void NingboTorchLightDisable(void)
{
    return;
}


void NingboTorchLightEnable(void)
{
    return;
}


void NingboVibratorCtrl(UINT8 level)
{
    return;
}


void NingboVibratorDisable(void)
{
    return;
}

void NingboVibratorEnable(void)
{
    return;
}

void Ningbo_ENABLE_BATID_MEAS(void)
{
    return;
}

void Ningbo_ENABLE_BATTEMP_MEAS(void)
{
    return;
}

UINT32 Ningbo_Get_Meas_Factor(NINGBO_MEAS_EN meas_en)
{
    return 0;
}

int Ningbo_LDO_Set_Enable(unsigned char reg, unsigned char enable)
{
    return 0;
}

int Ningbo_LDO_Set_VOUT(unsigned char reg, unsigned char value)
{
    return 0;
}

void Ningbo_Ldo_11_set(BOOL OnOff)
{
    return;
}

void Ningbo_Ldo_11_set_1_2(void)
{
    return;
}

void Ningbo_Ldo_12_set(BOOL OnOff)
{
    return;
}

void Ningbo_Ldo_12_set_1_8(void)
{
    return;
}

void Ningbo_Ldo_12_set_2_8(void)
{
    return;
}


void Ningbo_Ldo_1_set(BOOL OnOff)
{
    return;
}

void Ningbo_Ldo_1_set_2_8(void)
{
    return;
}

BAT_STATUS PM812_BATTERY_STATUS()
{
    return 0;
}

void pm813_cc_current_set(CC_CHG_CURRENT value)
{
    return;
}

void pm813_cccv_timer_set(UINT8 value)
{
    return;
}

void pm813_charge_termination_current_set(UINT8 value)
{
    return;
}

BOOL pm813_charger_is_usb(void)
{
    return 0;
}

void pm813_charger_switch(BOOL OnOff)
{
    return;
}

void pm813_fault_clear(void)
{
    return;
}

UINT32 pm813_get_Icharge_meas_cur_mA(void)
{
    return 0;
}

UINT32 pm813_get_Vcharge_meas_vol_mv(void)
{
    return 0;
}

UINT32 pm813_get_batid_meas_vol_mv(void)
{
    return 0;
}

UINT32 pm813_get_battemp_meas_vol_mv(void)
{
    return 0;
}

BOOL pm813_get_battery_status(void)
{
    return 0;
}

UINT32 pm813_get_battery_voltage_withoutCharger(void)
{
    return 0;
}

CHGFSM_OUT pm813_get_charger_FSM_state(void)
{
    return 0;
}

BOOL pm813_if_charge_full(void)
{
    return 0;
}

BOOL pm813_if_charge_in_cv_mode(void)
{
    return 0;
}

BOOL pm813_keypadbacklight_status_get(void)
{
    return 0;
}

BOOL pm813_lcdbacklight_status_get(void)
{
    return 0;
}

BOOL pm813_measured_current_means_charging(void)
{
    return 0;
}

void pm813_precharge_current_set(UINT8 value)
{
    return;
}

void pm813_precharge_timer_set(UINT8 value)
{
    return;
}

BOOL pm813_set_max_cc_current(UINT32 limit)
{
    return 0;
}

BOOL pm813_torchlight_status_get(void)
{
    return 0;
}

void pm813_trickle_timer_set(UINT8 value)
{
    return;
}

void pm813_vbat_set(VBAT_VOLTAGE value)
{
    return;
}

BOOL pm813_vibrator_status_get(void)
{
    return 0;
}


void PM812_BATTERY_BIND_INTC(BatIntCallback callback)
{
    return;
}

void PM812_BATTERY_INTC_ENABLE(BOOL onoff)
{
    return;
}

void PM812_CHARGER_BIND_INTC(ChgIntCallback callback)
{
    return;
}

void PM812_CHARGER_INTC_ENABLE(BOOL onoff)
{
    return;
}

void PM812_ENABLE_BAT_DET(BOOL onoff)
{
    return;
}

void pm813s_mppt_restart(void)
{
    return;
}



#endif

#if defined(NOT_SUPPORT_PMIC_ONKEY)
#include "pmic.h"
#include "pmic_onkey.h"

void PM812_LONKEY_EN(LONGKEY_COUNT num,BOOL enable)
{
    return;
}

void PM812_LONKEY_PRESS_TIME_SET(UINT8 sec)
{
    return;
}
ONKEY_STATUS PM812_GET_ONKEY_STATUS(void)
{
    return 0;
}
void PM812_ONKEY_BIND_INTC(OnkeyIntCallback callback)
{
    return;
}
void PM812_ONKEY_INTC_ENABLE(BOOL onoff)
{
    return;
}

void OnKeyPoweroff_Start(void)
{
	return;
}


#endif



#ifdef GPS_SUPPORT
extern int asr_gnss_open(void *);
extern void asr_gps_clear_packinfo(void);
int asr_gnss_open_stub(void)
{
#ifndef MIN_SYS
		if(!IsMiniSystem()) {
            asr_gps_clear_packinfo();
			asr_gnss_open(NULL);
		}
#endif

	return 0;
}

extern unsigned char get_gps_pm_lock(void);
unsigned char get_gps_pm_lock_stub(void)
{
#ifndef MIN_SYS
    if(!IsMiniSystem())
    {
        return get_gps_pm_lock();
    }
#endif

    return 0;
}

#endif


#ifndef NTP
int GetNTPStatus(void) //return 1 if there is platform ntp success
{
	return 0;
}
#endif

#ifndef CSDAPI_SUPPORT
VgFifo8 vgDataStackDsFifo;
VgFifo8 vgDsDataStackFifo;

void CsdQueryTestStatus(void)
{
    return;
}

void CsdTurnOffTest(void)
{
    return;
}

void CsdTurnOnTest(void)
{
    return;
}

void vgRlpSetRlpInitiateXidNeg(BOOL val)
{
    return;
}

void VgRtfdpTask (void)
{
    return;
}

void VgUfdpTask (void)
{
    return;
}
#endif

#ifdef MV_USB2_NO_USBNET
void Rndis_eh_indicate_disconnect_msg(void)
{
	return;
}

void EcmParamInit(void)
{
	return;
}
void Ecm_getstrECMMACADDR(UINT8 * strMac, UINT32 len)
{
	return;
}

int mvUsbGetTxNetQCnt(void)
{
	return 0;
}

void mvUsbNetIndicateStatus(BOOL connected)
{
	return;
}

void mvUsbNetSendPacket(UINT8* data, UINT32 len)
{
	return;
}


#endif

#if defined(NOT_SUPPORT_PM803)
#include "guilin_lite.h"

void GuilinLite_Ldo_3_set(BOOL OnOff)
{
    return;
}

void GuilinLite_Ldo_3_set_1_8(void)
{
    return;
}
void GuilinLite_Ldo_3_set_3_0(void)
{
    return;
}

void GuilinLite_Ldo_8_set(BOOL OnOff)
{
    return;
}
void GuilinLite_Ldo_8_set_1_8(void)
{
    return;
}

void GuilinLite_Ldo_8_set_3_0(void)
{
    return;
}

void GuilinLite_PowerSave_Config(void)
{
    return;
}


#endif

#if defined(NOT_SUPPORT_PM802)
#include "guilin.h"

void Guilin_Ldo_3_set(BOOL OnOff)
{
    return;
}

void Guilin_Ldo_3_set_1_8(void)
{
    return;
}   
void Guilin_Ldo_3_set_3_0(void)
{
    return;
}   
void Guilin_Ldo_4_set(BOOL OnOff) 
{
    return;
}

void Guilin_Ldo_4_set_1_8(void)
{
    return;
}


void Guilin_Ldo_4_set_3_0(void)
{
    return;
}

void Guilin_PowerSave_Config(void)
{

}


#endif

#if defined(NOT_SUPPORT_PM803L)
#include "guilin_lite2.h"

void GuilinLite2_Ldo_3_set(BOOL OnOff)
{
    return;
}

void GuilinLite2_Ldo_3_set_3_0(void)
{
    return;
}

void GuilinLite2_Ldo_3_set_1_8(void)
{
    return;
}

void GuilinLite2_PowerSave_Config(void)
{
    return;
}


#endif

#ifndef LZMA_SUPPORT
unsigned int LzmaUncompressLen(const unsigned char *src)
{
    unsigned int len = 0;
    int ii = 0;
    unsigned char *temp = NULL;

    temp = (unsigned char *)src + 5;
    for (ii = 0; ii < 4; ii++)
    {
        unsigned char b;
        b = *temp;
        temp++;
        len += (unsigned int)(b) << (ii * 8);
    }

    return len;
}
#endif

BOOL WifiScanIsEnable(void)
{
#ifdef ENABLE_WIFI_SCAN
	if(IsChipCraneLR())
	{
		char dsp_version1[64]={0};
		char dsp_date1[64]={0};

		extern void GetDspFWVersionAndDate(char *version, char *date);
		GetDspFWVersionAndDate(dsp_version1,dsp_date1);

		if((strlen(dsp_version1)) && (strstr(dsp_version1, "WIFI")))
		{
			return TRUE;
		}
		else
		{
			CPUartLogPrintf("%s:enable sw micro,but dsp not support wifiscan.", __func__);
			return FALSE;
		}
	}
	else
	{
		return TRUE;
	}
#else
	return FALSE;
#endif	
}
#endif