mcu/interface/service/dhl/v2/dhl_trace.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) 2012
*
*  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).
*
*****************************************************************************/

/****************************************************************************
 * Filename:
 * ---------
 *   @file dhl_trace.h
 *
 * Description:
 * ------------
 *   @brief Public interface of PS trace logging API.
 *
 * ==========================================================================
 * $Log$
 *
 * 01 14 2020 yh.sung
 * [MOLY00470593] [MP0.7 excluded][MT6885][Petrus][Alpha phone][MP1][SQC][SH][USIR][module_MM]Found user data in ELT Log
 * 	
 * 	.
 *
 * 12 06 2019 wen-ting.cheah
 * [MOLY00454404] [VMOLY] Remove legacy task
 * Remove unused task
 * 09 24 2019 yancy.chien
 * [MOLY00442628] [MT6885][Petrus][NR][MP1][ML1S][MT8000A]Assert fail: dhl_list.h 305 0x235381fc 0x27f89db0 0x0 - 6IDLE
 * Remove NRRC EBS solution.
 *
 * 09 18 2019 victoria.wang
 * [MOLY00416922] DHL Legacy Wrapper migration and phase-out
 * [Remove][DHL] phase out legacy wrapper API
 *
 * 06 13 2019 victoria.wang
 * [MOLY00408490] USIR Feature
 * [New][USIR][DHL] Add usir customsize masking function and enable USIR with modis
 *
 * 06 11 2019 sunwhy.kuo
 * [MOLY00412952] patch empty flush MDM buffer API to VMOLY for further ESP key delay issue
 * 	
 * 	patch empty mon buffer flush API for ESP Key delay (need implement when MDM channel done)
 *
 * 05 16 2019 yancy.chien
 * [MOLY00345863] [Gen97] RRC signal logging & inject
 * 	
 * 	Export MAX_TRACE_DATA_SEGMENT_CNT & MAX_ILM_TRACE_BYTES
 *
 * 05 16 2019 victoria.wang
 * [MOLY00354132] [Gen 95][ERRC][SYS] Stored SIB C-struct debug trace
 * [Add][DHL] print c structure logging API
 *
 * 05 02 2019 yancy.chien
 * [MOLY00345863] [Gen97] RRC signal logging & inject
 * interface part.
 *
 * 04 25 2019 yancy.chien
 * [MOLY00401562] Decouple ICD from DHL on VMOLY trunk
 * 	
 * 	1. Dynamic CCB.
 * 	2. Src Plug-in phase-in.
 * 	3. Fix build error on Gen95
 *
 * 04 21 2019 yh.sung
 * [MOLY00392990] [VMOLY][UTF] Phase 2 Landing
 * [UTF][DHL] UTF Trace API - trace interface
 *
 * 01 30 2019 yu-hsiang.peng
 * [MOLY00370849] [MT6297][Apollo][Sanity Fail][VMOLY][20181205][0200] 2G_Attach assert fail m12180.c 532
 * [SEPT.DEV] support custom read done
 *
 * 01 25 2019 yu-hsiang.peng
 * [MOLY00381457] [DHL 2.0] Common Feature Development
 * [SEPT.DEV] support mipi custom read
 *
 * 12 04 2018 yancy.chien
 * [MOLY00370246] [GEN97][DHL] META disconnect flow enhancement
 * 	
 * 	.
 *
 * 10 30 2018 yu-hsiang.peng
 * [MOLY00347960] [MT6297] DHL Feature Enhance
 * [Change Feature] Support AST logging - interface
 *
 * 09 28 2018 yancy.chien
 * [MOLY00345863] [Gen97] RRC signal logging & inject
 * UPS mux header support over 64K
 * UPS protocol phase-in
 * EBS add NRRC_LOG type
 * Custom ILM option remove no_log & wo_peer_buff
 *
 ****************************************************************************/

#ifndef _DHL_TRACE_H
#define _DHL_TRACE_H

#if !defined(__DHL_MODULE__)
#include "kal_trace.h"

#define dhl_trace(...)
#define dhl_internal_trace(...)
#define dhl_brief_trace(...)
#define dhl_peer_trace(...)
#define dhl_raw_trace(...)
#define dhl_print(...)
#define dhl_print_string(...)
#define dhl_print_system_trace(...)

#define dhl_print_struct(...)
#define dhl_debug_print(...)

#define dhl_trace_impl(...)
#define dhl_internal_trace_impl(...)
#define dhl_print_impl(...)
#define dhl_EM_logger(...)
#define dhl_log_primitive6(...)

#define dhl_print_meta_string(...)

#define DHL_MAC_LOG_L2_PDU(pointer, length) do {\
    } while(0)
#define DHL_RLC_LOG_L2_PDU(pointer, length) do {\
    } while(0)
#define DHL_PDCP_LOG_L2_PDU(pointer, length) do {\
    }while(0)

#define DHL_MAC_CHECK_L2_PDU() do {\
    }while(0)
#define DHL_RLC_CHECK_L2_PDU() do {\
    }while(0)
#define DHL_PDCP_CHECK_L2_PDU() do {\
    }while(0)
#define dhl_get_md_time_info (0)
#else

#ifndef GEN_FOR_PC
#include <stdio.h>
#include <stdarg.h>
#else
typedef char *va_list;
#endif
#include "kal_general_types.h"
#include "kal_public_defs.h"

#if defined(__RVCT__)
#pragma diag_suppress 870
#endif /* __RVCT_ */

#ifdef __cplusplus
extern "C" {
#endif

#if defined(__DHL_MODULE__) && defined(__EM_MODE__) /* for ilm_struct type definition */
#ifndef GEN_FOR_PC
struct ilm_struct;
extern void tst_EM_logger(struct ilm_struct *ilm_ptr);
extern void dhl_EM_logger(struct ilm_struct *ilm_ptr);
#endif
#endif  //#if defined(__DHL_MODULE__) && defined(__EM_MODE__)

#define MAX_MSG_NBR_IN_MODULE       20

//Define Trace Macro for PS trace
#if defined(GEN_FOR_PC) && !defined(GEN_FOR_CPARSER)
#define BEGIN_TRACE_MAP(MOD)     START_MODULE_MSG MOD MAX_MSG_NBR_IN_MODULE
#define BEGIN_TRACE_MAP_WITH_RANGE(MOD, MIN_VAL, MAX_VAL) START_RANGE_MODULE_MSG MOD MAX_MSG_NBR_IN_MODULE MIN_VAL MAX_VAL
#define TRC_MSG(MSG,STR)         MSG STR
#define TRC_MSG_NEWLINE(MSG,STR,NUM)         MSG STR NUM
#define END_TRACE_MAP(MOD)       END_MODULE_MSG
#define END_TRACE_MAP_WITH_RANGE(MOD, MIN_VAL, MAX_VAL)   MOD MIN_VAL MAX_VAL END_RANGE_MODULE_MSG
#else //Define Trace Macro for PS trace
#define BEGIN_TRACE_MAP(MOD)     enum MOD##_MSG_ENUM{\
    MOD##_empty_string=MOD<<MAX_MSG_NBR_IN_MODULE,
#define BEGIN_TRACE_MAP_WITH_RANGE(MOD, MIN_VAL, MAX_VAL) enum MOD##_##MIN_VAL##_MSG_ENUM{\
    MOD##_##MIN_VAL##_empty_string = (MOD<<MAX_MSG_NBR_IN_MODULE) + MIN_VAL - 1,
#define TRC_MSG(MSG,STR)         MSG##__enum,
#define TRC_MSG_NEWLINE(MSG,STR,NUM)         MSG##__enum, MSG##_NEWLINE_EXPAND__enum = MSG##__enum+NUM,
#define  END_TRACE_MAP(MOD)      MOD##__end};
#define  END_TRACE_MAP_WITH_RANGE(MOD, MIN_VAL, MAX_VAL)  MOD##_##MIN_VAL##__end};
#endif //Define Trace Macro for PS trace


#if defined(__DHL_MODULE__) && !defined(__DHL_BRINUP_DUMMY_BUILD__)
#define __DHL_TRACE_ENABLED__
#endif  //#ifdef __DHL_MODULE__

#ifndef __DHL_TRACE_ENABLED__
#if defined(L1_SIM) && !defined (__UE_SIMULATOR__)
#define __DHL_TRACE_ENABLED__
#elif defined(KAL_ON_OSCAR) || defined(MCD_DLL_EXPORT)
#define __DHL_TRACE_EMPTY_FUNCTION__
#endif  //#if defined(KAL_ON_OSCAR) || defined(MCD_DLL_EXPORT)
#endif

typedef enum
{
    TRACE_FUNC,
    TRACE_STATE,
    TRACE_INFO,
    TRACE_WARNING,
    TRACE_ERROR,
    TRACE_GROUP_1,
    TRACE_GROUP_2,
    TRACE_GROUP_3,
    TRACE_GROUP_4,
    TRACE_GROUP_5,
    TRACE_GROUP_6,
    TRACE_GROUP_7,
    TRACE_GROUP_8,
    TRACE_GROUP_9,
    TRACE_GROUP_10,
    TRACE_PEER
} trace_class_enum;

typedef enum
{
    DHL_CUSTOM_ILM_HEADER_ONLY,
    DHL_CUSTOM_ILM_CPHY_MSG_CONTAINER,
} e_custom_ilm_trace_option;

typedef struct
{
    void*      data;
    kal_uint32 len;
} trace_data_segment_desc;


#if defined (__DHL_TRACE_ENABLED__)

#define DHL_USER_FLAG_NONE          (0x0)
#define DHL_FLAG_EM                 (0x1)

/* User API for querying trace started to output or not, contact: Shengfu Tsai */
extern kal_bool dhl_is_trace_started();

/* User API for querying USIR on to mask sensitive data or not */
kal_bool dhl_mask_sensitive_trace_on();

/* trace */
#define DHL_ACCESS_LEVEL_1_ALL_USER             (0x01)
#define DHL_ACCESS_LEVEL_4_MTK_INTERNAL         (0x04)
#define DHL_ACCESS_LEVEL_5_MBJ_L1               (0x05)
#define DHL_ACCESS_LEVEL_5_MTB_L1               (0x05)
#define DHL_ACCESS_LEVEL_7_HQ_ONLY              (0x07)
/* trace */
extern void dhl_print(trace_class_enum trc_class, kal_uint32 user_flag, module_type mod_id, const char *fmt, ...);
extern void dhl_print_string(trace_class_enum trc_class, kal_uint32 user_flag, module_type mod_id, const char *str);
extern void meta_print_string(trace_class_enum trc_class, kal_uint32 user_flag, module_type mod_id, const char *str);
#define dhl_print_system_trace(_c, _s) \
    dhl_print_string((_c), DHL_USER_FLAG_NONE, 0, (_s));

/* primitive */
/**
* \brief output internal message communication log if module's filter on. send by KAL service.
* \param ilm_struct for internal message
*/
extern void dhl_log_primitive(ilm_struct *ilm);
extern void dhl_log_primitive_custom(ilm_struct *ilm, e_custom_ilm_trace_option option);

#define DHL_MAX_TRACE_DATA_SEGMENT_CNT (128)
#define DHL_MAX_ILM_TRACE_BYTES        (512 * 1024)
/*
 * Pack the data_seg_array's data in ILM's peer part
 * NOTE:
 *      1. original peer_buf_ptr & peer_buf_len of ILM will be replaced
 *      2. local_para_len can be controlled by partial logging, but peer_len CAN'T
 *      3. ASSURE data_seg_cnt <= DHL_MAX_TRACE_DATA_SEGMENT_CNT
 *      4. ASSURE total size of trace <= DHL_MAX_ILM_TRACE_SIZE
 */
extern void dhl_log_primitive_append_data_in_peer(ilm_struct *ilm, trace_data_segment_desc data_seg_array[], kal_uint32 data_seg_cnt);

extern void dhl_FT_log_primitive(ilm_struct *ilm);

/**
* \brief output primitive C structure if module's filter on.
* \param module's id
* \param sap_type if need partial logging
* \param msg_type for getting c structure that define in message structure definition
* \param buf_len the size of c structure
* \param buf pointer to the stucture data
* \par Sample code
* \code{.c}
* dhl_string_struct buf; 
* kal_uint32 buf_len = sizeof(dhl_string_struct);
* dhl_log_primitive_struct(MOD_DHL, INVALID_SAP, MSG_ID_DHL_STRING, buf_len, &buf);
* \endcode
*/
extern void dhl_log_primitive_struct(module_type src_mod, sap_type sap_id,  msg_type msg_id, kal_uint32 buf_len, void *buf);
// API for META
// Exported API for FT only, FT will call this API after send disconnect ACK to Tool, then DHL will drop all upcoming META traces to save power
// NOTE: Not thread-safe
extern void dhl_set_meta_tool_disconnected();

extern void meta_print_system_trace(trace_class_enum trc_class, kal_uint32 user_flag, module_type mod_id, const kal_char *str);
#define dhl_print_meta_string(_c, _s)  meta_print_system_trace((_c), DHL_USER_FLAG_NONE, 0, (_s))


// Only available on MoDIS
#ifdef UNIT_TEST
#include "kal_public_defs.h"
extern void _dhl_print_struct(module_type src, msg_type msg_id, int buf_len, void *buf);
#define dhl_print_struct(_s,_m,_l,_b) _dhl_print_struct(_s,_m,_l,_b)
#define dhl_debug_print(_c,_m,_f, ...) dhl_print(_c, DHL_USER_FLAG_NONE, _m, _f, __VA_ARGS__);
#else
#define dhl_print_struct(_s,_m,_l,_b)
#define dhl_debug_print(_f, ...)
#endif

#define dhl_trace_impl(_t, _u, _msg, _mod, _argv, _arg_info) \
    dhl_internal_trace_impl(_t, _u, DHL_ACCESS_LEVEL_1_ALL_USER, _msg, _mod, _argv, _arg_info)

extern void dhl_internal_trace_impl(trace_class_enum trc_class, kal_uint32 user_flag, kal_uint8 access_level, kal_uint32 msg_index, kal_uint32 module_id, const char *arg_type, va_list argument_info);
extern void dhl_print_impl(trace_class_enum trc_class, kal_uint32 user_flag, module_type mod_id, const char *fmt, va_list argument_info);
extern void dhl_raw_trace_impl(trace_class_enum trc_class, kal_uint32 user_flag, kal_uint32 msg_index, const kal_char *fmt, kal_uint32 buf_len, const kal_uint8 *pData, kal_bool chk_filter);
/**
 * @brief this is intended as internal API implementation of DHL
 * Do not use this directly. User must declare UTMD to use OTA traces.
 * @param trc_class trace class ID to check filter
 * @param global_peer_msg_id OTA message identifier for given OTA message
 * @param raw_data_len length of given OTA message
 * @param raw_data pointer to OTA message buffer
 * @param trace_index trace ID of this OTA message
 * @param module_id trace module ID for filter checking
 * @param arg_type trace argumeargument for given trace
 *  */
extern void dhl_peer_trace_impl(kal_uint8 trc_class, kal_uint32 global_peer_msg_id, kal_uint32 raw_data_len, kal_uint8 *raw_data, kal_uint32 trace_index, kal_uint32 module_id, const char *arg_type, va_list argument_info);

//typedef void (*TST_String_Inject_CB)(kal_uint32 index, kal_uint8 *pData);
// External buffer logging via ILM
typedef enum
{
    DHL_EXTERNAL_BUFFER_TYPE_BEGIN = 0,
    DHL_EXTERNAL_BUFFER_L2COPRO_IP_HEADER_LOG,
    DHL_EXTERNAL_BUFFER_TYPE_MAX
} dhl_external_buffer_type;

/*
 * Parameter note:
 * sent_end
 *    the end of buffer address sent
 *    may not align with the buffer end sent
 *    (fragment should be handled by user)
 */
typedef void (*buffer_tx_done_cb)(dhl_external_buffer_type type, kal_uint8 *sent_end, kal_int32 sent_len);
kal_bool register_buffer_tx_done_callback(dhl_external_buffer_type type, buffer_tx_done_cb cb);
/*
 * Parameter usage note:
 * msg_id
 *    MSG_ID_DHL_L2COPRO_DL_IP_HEADER_LOG
 *    MSG_ID_DHL_L2COPRO_UL_IP_HEADER_LOG
 * local_para
 *    caller-free
 * local_para_len
 *    <= 64 bytes
 */
typedef struct
{
    kal_uint8 *buf_address;
    kal_uint32 buf_len;
} S_DHL_SEND_BODY;
kal_bool dhl_send_ilm_log(dhl_external_buffer_type type, msg_type msg_id, kal_uint8 *local_para, kal_int32 local_para_len, S_DHL_SEND_BODY *p_send_body_array, kal_uint32 body_number);

//for SIM Authentication APDU flush mdm buffer use , need implement in DHL v2
void dhl_mon_trigger_flush_log();

#ifdef TST_TRACE_COMPAT
#define kal_print_string_trace kal_wap_trace  //alias kal_print_string_trace as kal_wap_trace
extern void kal_wap_trace(module_type mod_id, trace_class_enum trc_class, const char *fmt, ...);
extern void kal_bootup_trace(trace_class_enum, kal_uint32, const kal_char *, ...);
extern void kal_prompt_trace(module_type, const kal_char *fmt, ...);
extern void kal_trace_for_3rd_party(trace_class_enum, kal_uint32, const kal_char *, va_list);
#endif
//#define __DHL_LEGACY_TRACE_API_ENABLED__
#if defined(__DHL_LEGACY_TRACE_API_ENABLED__)
/*index trace & raw trace & peer trace*/
/*dhl*/
extern void dhl_trace(trace_class_enum trc_class, kal_uint32 user_flag, kal_uint32 msg_index, const char *arg_type, ...);
extern void dhl_internal_trace(trace_class_enum trc_class, kal_uint32 user_flag, kal_uint8 access_level, kal_uint32 msg_index, const char *arg_type, ...);
extern void dhl_brief_trace(trace_class_enum trc_class, kal_uint32 user_flag, kal_uint32 msg_index, const char *arg_type, ...);
extern void dhl_raw_trace(trace_class_enum trc_class, kal_uint32 user_flag, kal_uint32 msg_index, const kal_char *fmt, kal_uint32 buf_len, const kal_uint8 *pData);
extern void dhl_peer_trace(kal_uint32 global_peer_msg_id, kal_uint32 raw_data_len, kal_uint8 *raw_data, kal_uint32 trace_index, const char *arg_type, ...);
/*kal*/
#ifdef TST_TRACE_COMPAT
#define kal_critical_trace kal_trace
#define kal_critical_brief_trace kal_brief_trace
#define kal_critical_assert_trace kal_assert_trace
extern void kal_critical_trace(trace_class_enum, kal_uint32, const kal_char *, ...);
extern void kal_critical_brief_trace(trace_class_enum, kal_uint32, const kal_char *, ...);
extern void kal_critical_assert_trace(trace_class_enum, kal_uint32, const kal_char *, ...);
#if !defined(_MSC_VER)
#define kal_trace(trc_class, msg_index, ...) \
    dhl_trace(trc_class, DHL_USER_FLAG_NONE, msg_index, ##__VA_ARGS__)
#define kal_brief_trace(trc_class, msg_index, ...) \
    dhl_brief_trace(trc_class, DHL_USER_FLAG_NONE, msg_index, ##__VA_ARGS__)
//Target build
extern kal_bool tst_is_PsTrc_open_and_pstrace_flag;  //For optimization, the AND flag of tst_is_PsTrc_open and tst_pstrace_flag
extern void dhl_brief_trace_opt_helper(trace_class_enum trc_class, kal_uint32 user_flag, kal_uint32 msg_index, const char *arg_type, ...);
#define kal_brief_trace_macro(trc_class, msg_index, ...) do { \
    if (tst_is_PsTrc_open_and_pstrace_flag) {\
        dhl_brief_trace_opt_helper(trc_class, DHL_USER_FLAG_NONE, msg_index, ##__VA_ARGS__); \
    } \
    } while(0)
#else
extern void kal_trace(trace_class_enum, kal_uint32, const kal_char *, ...);
extern void kal_brief_trace(trace_class_enum, kal_uint32, const kal_char *, ...);
//PC build (MoDIS or MCDDLL)
extern void kal_brief_trace_macro(trace_class_enum, kal_uint32, const kal_char *, ...);
#endif // _MSC_VER
extern void _kal_trace(trace_class_enum, kal_uint32, const kal_char *, ...);
extern void _kal_brief_trace(trace_class_enum, kal_uint32, const kal_char *, ...);
extern void kal_lib_trace(trace_class_enum, kal_uint32, const kal_char *, ...);
//extern void kal_assert_trace(trace_class_enum, kal_uint32, const kal_char *, ...);
#define kal_assert_trace(trc_class, msg_index, ...) dhl_trace(trc_class, DHL_USER_FLAG_NONE, msg_index, ##__VA_ARGS__)
extern void kal_buffer_trace(trace_class_enum trc_class, kal_uint32 msg_index, const kal_char *fmt, kal_uint32 buf_len, const kal_uint8 *pData);
extern void kal_dev_trace(trace_class_enum trc_class, kal_uint32 msg_index, const char *arg_type, ...);
#endif // TST_TRACE_COMPAT
#endif //__DHL_LEGACY_TRACE_API_ENABLED__
/**
 * @brief get MD time info
 * @returns the current time info (32-bit)
 */
kal_uint32 dhl_get_md_time_info(void);
#else //__DHL_TRACE_ENABLED__
#if defined(__DHL_TRACE_EMPTY_FUNCTION__)
/*
 * For non-target platform (PC simulator or MNT),
 * we define trace-related functions as inline function to avoid compile error
 * in VC++.
 */

static __inline void dhl_trace(trace_class_enum trc_class, kal_uint32 user_flag, kal_uint32 msg_index, const char *arg_type, ...)
{
    return;
}

static __inline void dhl_internal_trace(trace_class_enum trc_class, kal_uint32 user_flag, kal_uint8 access_level, kal_uint32 msg_index, const char *arg_type, ...)
{
    return;
}

static __inline void dhl_brief_trace(trace_class_enum trc_class, kal_uint32 user_flag, kal_uint32 msg_index, const char *arg_type, ...)
{
    return;
}

static __inline void dhl_raw_trace(trace_class_enum trc_class, kal_uint32 user_flag, kal_uint32 msg_index, const kal_char *fmt, kal_uint32 buf_len, const kal_uint8 *pData)
{
    return;
}

static __inline void dhl_print(trace_class_enum trc_class, kal_uint32 user_flag, module_type mod_id, const char *fmt, ...)
{
    return;
}

#define dhl_print_system_trace(_c, _s)
#define dhl_print_struct(_s,_m,_l,_b)
#define dhl_debug_print(_f, ...)

static __inline void dhl_peer_trace(kal_uint32 global_peer_msg_id, kal_uint32 raw_data_len, kal_uint8 *raw_data, kal_uint32 trace_index, const char *arg_type, ...)
{
    return;
}

static __inline void dhl_trace_impl(trace_class_enum trc_class, kal_uint32 user_flag, kal_uint32 msg_index, const char *arg_type, va_list argument_info)
{
    return;
}

static __inline void dhl_print_impl(trace_class_enum trc_class, kal_uint32 user_flag, module_type mod_id, const char *fmt, va_list argument_info)
{
    return;
}

static __inline void kal_critical_trace(trace_class_enum trc_class, kal_uint32 msg_index, const kal_char *arg_type, ...)
{
    return ;
}

static __inline void kal_critical_brief_trace(trace_class_enum trc_class, kal_uint32 msg_index, const kal_char *arg_type, ...)
{
    return ;
}
static __inline void kal_critical_assert_trace(trace_class_enum trc_class, kal_uint32 msg_index, const kal_char *arg_type, ...)
{
    return ;
}


static __inline void kal_trace(trace_class_enum trc_class, kal_uint32 msg_index, const kal_char *arg_type, ...)
{
    return ;
}

static __inline void kal_brief_trace(trace_class_enum trc_class, kal_uint32 msg_index, const kal_char *arg_type, ...)
{
    return ;
}

static __inline void kal_brief_trace_macro(trace_class_enum trc_class, kal_uint32 msg_index, const kal_char *arg_type, ...)
{
    return ;
}

static __inline void kal_trace_for_3rd_party(trace_class_enum trc_class, kal_uint32 msg_index, const kal_char *arg_type, va_list argument_info)
{
    return ;
}

static __inline void kal_lib_trace(trace_class_enum trc_class, kal_uint32 msg_index, const kal_char *arg_type, ...)
{
    return ;
}
static __inline void kal_assert_trace(trace_class_enum trc_class, kal_uint32 msg_index, const kal_char *arg_type, ...)
{
    return ;
}
static __inline void kal_wap_trace(module_type mod_id, trace_class_enum trc_class, const char *fmt, ...)
{
    return ;
}
static __inline void kal_print_string_trace(module_type mod_id, trace_class_enum trc_class, const char *fmt, ...)
{
    return ;
}

static __inline void kal_buffer_trace(trace_class_enum trc_class, kal_uint32 msg_index, const kal_char *fmt, kal_uint32 buf_len, const kal_uint8 *pData)
{
    return;
}

static __inline void kal_dev_trace(trace_class_enum trc_class, kal_uint32 msg_index, const char *arg_type, ...)
{
    return;
}

static __inline void kal_bootup_trace(trace_class_enum trc_class, kal_uint32 msg_index, const kal_char *arg_type, ...)
{
    return ;
}

#if !defined(__LTE_REMOVE_TEMPERAL__)
static __inline void kal_prompt_trace(module_type mod_id, const kal_char *fmt, ...)
{
    return;
}
#endif /* end of !__LTE_REMOVE_TEMPERAL__ */
#else // __DHL_TRACE_EMPTY_FUNCTION__
//Define empty functions for Target SW
#define dhl_trace(...)
#define dhl_internal_trace(...)
#define dhl_brief_trace(...)
#define dhl_raw_trace(...)
#define dhl_print(...)
#define dhl_print_string(...)
#define dhl_print_system_trace(...)

#define dhl_print_struct(...)
#define dhl_debug_print(...)
#define dhl_peer_trace(...)

#define dhl_trace_impl(...)
#define dhl_print_impl(...)
#define dhl_internal_trace_impl(...)

#define kal_trace(...)
#define kal_brief_trace(...)
#define _kal_trace(...)
#define _kal_brief_trace(...)
#define kal_brief_trace_macro(...)
#define kal_trace_for_3rd_party(...)
#define kal_lib_trace(...)
#define kal_assert_trace(...)
#define kal_wap_trace(...)
#define kal_print_string_trace(...)
#define kal_buffer_trace(...)
#define kal_dev_trace(...)
#define kal_bootup_trace(...)
#define kal_prompt_trace(...)
#define kal_critical_trace(...)
#define kal_critical_brief_trace(...)
#define kal_critical_assert_trace(...)

#define dhl_EM_logger(...)
#define dhl_brief_trace_opt_helper(...)
#endif
#endif

#define kal_sys_trace        tst_sys_trace
#define kal_sys_init_trace   tst_sys_init_trace
#define kal_sys_fatal_trace  tst_sysfatal_trace

#if defined(__DHL_MODULE__)
// TODO:  liberrc_mob_com.c & kal_msg_passing.c extern tst_log_primitive, ask them to remove!!
extern void tst_log_primitive(ilm_struct *ilm_ptr);
//#define tst_log_primitive(ilm)   dhl_log_primitive(ilm)

// TODO: l1tst_fnc_l1rf.c 194 extern tst_sys_trace, ask them to remove!!
extern void tst_sys_trace(kal_char *info);
//#define tst_sys_trace(mesg)      dhl_print_system_trace(TRACE_INFO,mesg)

// these APIs can be replaced by macro directlly
#define tst_sysfatal_trace(mesg) dhl_print_system_trace(TRACE_ERROR, mesg)
#define tst_sys_init_trace       tst_sys_trace


extern kal_int32 tst_trace_check_ps_filter_off(trace_class_enum trc_class, kal_uint32 *module_id, kal_uint32 supportOption);

#define kal_bootup_print tst_sys_init_trace
#else
#ifdef __DHL_TRACE_EMPTY_FUNCTION__
#if !defined(__LTE_REMOVE_TEMPERAL__)
static __inline void tst_sys_init_trace(const kal_char *info)
{
return ;
}
static __inline void tst_sys_trace(kal_char *info)
{
return ;
}
static __inline void tst_sysfatal_trace(kal_char *info)
{
return ;
}
static __inline kal_int32 tst_trace_check_ps_filter_off(trace_class_enum trc_class, kal_uint32 *module_id, kal_uint32 supportOption)
{
return ;
}
#endif /* end of !__LTE_REMOVE_TEMPERAL__ */
#else
#define tst_sys_init_trace(...)
#define tst_sys_trace(...)
#define tst_sysfatal_trace(...)
#define tst_trace_check_ps_filter_off(...)
#endif
#endif  //#ifdef __DHL_MODULE__

typedef void (*TST_VC_CallBack)(const kal_uint8 *pData, kal_uint32 nLen);
typedef void (*TST_String_Inject_CB)(kal_uint32 index, kal_uint8 *pData);

/*
* tst_virtual_channel_id:
* regiester new virtual channel here and remake tst
*/
typedef enum
{
    TVCI_GPS_LOGGING,
    TVCI_DNT_L2COPRO_LOGGING,
    TVCI_CATCHER_POLLING,
    TVCI_GDB_COMM,
    TVCI_AST_LOGGING,
    TVCI_MINI_LOG,
    TVCI_VM_LOGGING,
    TVCI_BTT,
    TVCI_LAST_ID
}
tst_virtual_channel_id;

#define MAX_VC_RESPONSE_LEN (1023)

kal_bool tst_vc_register_channel(tst_virtual_channel_id channel_id, TST_VC_CallBack fnCmd);
kal_bool tst_vc_response(tst_virtual_channel_id channel_id, const kal_uint8 *pData, kal_uint16 len);
void dhl_vc_send_ast_log(kal_uint8 * buf, kal_uint16 data_len);

#define TVCI_CREATE_FILE 0x24540001
#define TVCI_CLOSE_FILE 0x24540002

kal_bool dhl_get_assert_bypass_buf(kal_char **buf, kal_uint32 *buf_size, kal_uint32 *buf_index);
kal_bool dhl_ack_assert_bypass_buf(kal_char *buf, kal_uint32 message_size, kal_uint32 buf_index);

void dhl_log_primitive6(module_type src_mod_id, module_type dest_mod_id, sap_type sap_id, msg_type msg_id, local_para_struct *local_para_ptr, peer_buff_struct *peer_buff_ptr);

typedef enum
{
    DHL_CUSTOM_MEM_PMIC,
    DHL_CUSTOM_MEM_MIPI,
    DHL_CUSTOM_MEM_MAX
} DHL_CUSTOM_MEM_TYPE;

typedef void (*DHL_CUSTOM_READ_MEM_CALLBACK)(void *read_addr, kal_uint32 len, kal_uint32 option, void **read_buffer_addr, kal_uint32 *read_buffer_len);
typedef void (*DHL_CUSTOM_READ_MEM_DONE_CALLBACK)(void *read_addr, kal_uint32 len, kal_uint32 option);
typedef void (*DHL_CUSTOM_WRITE_MEM_CALLBACK)(void *write_addr, kal_uint32 len, kal_uint32 option, void *write_buffer_addr);

kal_bool dhl_register_custom_mem_read(DHL_CUSTOM_MEM_TYPE mem_type, DHL_CUSTOM_READ_MEM_CALLBACK read_cb);
kal_bool dhl_register_custom_mem_read_done(DHL_CUSTOM_MEM_TYPE mem_type, DHL_CUSTOM_READ_MEM_DONE_CALLBACK read_done_cb);
kal_bool dhl_register_custom_mem_write(DHL_CUSTOM_MEM_TYPE mem_type, DHL_CUSTOM_WRITE_MEM_CALLBACK write_cb);

#ifdef __cplusplus
}
#endif


typedef enum
{
    /* 0~7 reserve for L2 PDU */
    /* should not over DHL_L2_PDU_TYPE_NUM */
    DHL_L2_PDU_MAC_TYPE = 1,
    DHL_L2_PDU_RLC_TYPE = 2,
    DHL_L2_PDU_PDCP_TYPE = 3,
    DHL_L2_PDU_RLC_PDU_TYPE = 4,
} dhl_log_pdu_type;

void dhl_log_pdu(dhl_log_pdu_type type, kal_uint8 *data, kal_uint32 length);
void dhl_flush_pdu(dhl_log_pdu_type type);
kal_bool dhl_check_pdu_filter(dhl_log_pdu_type type);

#define DHL_MAC_CHECK_L2_PDU() dhl_check_pdu_filter(DHL_L2_PDU_MAC_TYPE)
#define DHL_RLC_CHECK_L2_PDU() (dhl_check_pdu_filter(DHL_L2_PDU_RLC_TYPE) || dhl_check_pdu_filter(DHL_L2_PDU_RLC_PDU_TYPE))
#define DHL_PDCP_CHECK_L2_PDU() dhl_check_pdu_filter(DHL_L2_PDU_PDCP_TYPE)

#define DHL_MAC_LOG_L2_PDU(pointer, length) do {          \
        if(DHL_MAC_CHECK_L2_PDU()) {       \
            dhl_log_pdu(DHL_L2_PDU_MAC_TYPE, pointer, length);\
        }                                                     \
    } while(0)
#define DHL_RLC_LOG_L2_PDU(pointer, length) do {          \
        if(DHL_RLC_CHECK_L2_PDU()) {       \
            dhl_log_pdu(DHL_L2_PDU_RLC_TYPE, pointer, length);\
        }                                                     \
    } while(0)
#define DHL_PDCP_LOG_L2_PDU(pointer, length) do {          \
        if(DHL_PDCP_CHECK_L2_PDU()) {       \
            dhl_log_pdu(DHL_L2_PDU_PDCP_TYPE, pointer, length);\
        }                                                      \
    }while(0)

#endif
#endif /* _DHL_TRACE_H */