bcmdhd.101.10.361.x/dhd_pktlog.h - manifest_repos/dhd-driver - Git at Google

 /*
  * DHD debugability packet logging header file
  *
  * Copyright (C) 2020, Broadcom.
  *
  *      Unless you and Broadcom execute a separate written software license
  * agreement governing use of this software, this software is licensed to you
  * under the terms of the GNU General Public License version 2 (the "GPL"),
  * available at http://www.broadcom.com/licenses/GPLv2.php, with the
  * following added to such license:
  *
  *      As a special exception, the copyright holders of this software give you
  * permission to link this software with independent modules, and to copy and
  * distribute the resulting executable under terms of your choice, provided that
  * you also meet, for each linked independent module, the terms and conditions of
  * the license of that module.  An independent module is a module which is not
  * derived from this software.  The special exception does not apply to any
  * modifications of the software.
  *
  *
  * <<Broadcom-WL-IPTag/Open:>>
  *
  * $Id$
  */

 #ifndef __DHD_PKTLOG_H_
 #define __DHD_PKTLOG_H_

 #include <dhd_debug.h>
 #include <dhd.h>
 #include <asm/atomic.h>
 #ifdef DHD_COMPACT_PKT_LOG
 #include <linux/rbtree.h>
 #endif	/* DHD_COMPACT_PKT_LOG */

 #ifdef DHD_PKT_LOGGING
 #define DHD_PKT_LOG(args)	DHD_INFO(args)
 #define DEFAULT_MULTIPLE_PKTLOG_BUF	1
 #ifndef CUSTOM_MULTIPLE_PKTLOG_BUF
 #define CUSTOM_MULTIPLE_PKTLOG_BUF	DEFAULT_MULTIPLE_PKTLOG_BUF
 #endif /* CUSTOM_MULTIPLE_PKTLOG_BUF */
 #define MIN_PKTLOG_LEN			(32 * 10 * 2 * CUSTOM_MULTIPLE_PKTLOG_BUF)
 #define MAX_PKTLOG_LEN			(32 * 10 * 2 * 10)
 #define MAX_DHD_PKTLOG_FILTER_LEN	14
 #define MAX_MASK_PATTERN_FILTER_LEN	64
 #define PKTLOG_TXPKT_CASE		0x0001
 #define PKTLOG_TXSTATUS_CASE		0x0002
 #define PKTLOG_RXPKT_CASE		0x0004
 /* MAX_FILTER_PATTERN_LEN is buf len to print bitmask/pattern with string */
 #define MAX_FILTER_PATTERN_LEN \
 	((MAX_MASK_PATTERN_FILTER_LEN * HD_BYTE_SIZE) + HD_PREFIX_SIZE + 1) * 2
 #define PKTLOG_DUMP_BUF_SIZE		(64 * 1024)

 typedef struct dhd_dbg_pktlog_info {
 	frame_type payload_type;
 	size_t pkt_len;
 	uint32 driver_ts_sec;
 	uint32 driver_ts_usec;
 	uint32 firmware_ts;
 	uint32 pkt_hash;
 	bool direction;
 	void *pkt;
 } dhd_dbg_pktlog_info_t;

 typedef struct dhd_pktlog_ring_info
 {
 	dll_t p_info;			/* list pointer */
 	union {
 		wifi_tx_packet_fate tx_fate;
 		wifi_rx_packet_fate rx_fate;
 		uint32 fate;
 	};
 	dhd_dbg_pktlog_info_t info;
 } dhd_pktlog_ring_info_t;

 typedef struct dhd_pktlog_ring
 {
 	dll_t ring_info_head;		/* ring_info list */
 	dll_t ring_info_free;		/* ring_info free list */
 	osl_atomic_t start;
 	uint32 pktlog_minmize;
 	uint32 pktlog_len;		/* size of pkts */
 	uint32 pktcount;
 	spinlock_t *pktlog_ring_lock;
 	dhd_pub_t *dhdp;
 	dhd_pktlog_ring_info_t *ring_info_mem; /* ring_info mem pointer */
 } dhd_pktlog_ring_t;

 typedef struct dhd_pktlog_filter_info
 {
 	uint32 id;
 	uint32 offset;
 	uint32 size_bytes; /* Size of pattern. */
 	uint32 enable;
 	uint8 mask[MAX_MASK_PATTERN_FILTER_LEN];
 	uint8 pattern[MAX_MASK_PATTERN_FILTER_LEN];
 } dhd_pktlog_filter_info_t;

 typedef struct dhd_pktlog_filter
 {
 	dhd_pktlog_filter_info_t *info;
 	uint32 list_cnt;
 	uint32 enable;
 } dhd_pktlog_filter_t;

 typedef struct dhd_pktlog
 {
 	struct dhd_pktlog_ring *pktlog_ring;
 	struct dhd_pktlog_filter *pktlog_filter;
 	osl_atomic_t pktlog_status;
 	dhd_pub_t *dhdp;
 #ifdef DHD_COMPACT_PKT_LOG
 	struct rb_root cpkt_log_tt_rbt;
 #endif  /* DHD_COMPACT_PKT_LOG */
 } dhd_pktlog_t;

 typedef struct dhd_pktlog_pcap_hdr
 {
 	uint32 magic_number;
 	uint16 version_major;
 	uint16 version_minor;
 	uint16 thiszone;
 	uint32 sigfigs;
 	uint32 snaplen;
 	uint32 network;
 } dhd_pktlog_pcap_hdr_t;

 #define PKTLOG_PCAP_MAGIC_NUM 0xa1b2c3d4
 #define PKTLOG_PCAP_MAJOR_VER 0x02
 #define PKTLOG_PCAP_MINOR_VER 0x04
 #define PKTLOG_PCAP_SNAP_LEN 0x40000
 #define PKTLOG_PCAP_NETWORK_TYPE 147

 extern int dhd_os_attach_pktlog(dhd_pub_t *dhdp);
 extern int dhd_os_detach_pktlog(dhd_pub_t *dhdp);
 extern dhd_pktlog_ring_t* dhd_pktlog_ring_init(dhd_pub_t *dhdp, int size);
 extern int dhd_pktlog_ring_deinit(dhd_pub_t *dhdp, dhd_pktlog_ring_t *ring);
 extern int dhd_pktlog_ring_set_nextpos(dhd_pktlog_ring_t *ringbuf);
 extern int dhd_pktlog_ring_get_nextbuf(dhd_pktlog_ring_t *ringbuf, void **data);
 extern int dhd_pktlog_ring_set_prevpos(dhd_pktlog_ring_t *ringbuf);
 extern int dhd_pktlog_ring_get_prevbuf(dhd_pktlog_ring_t *ringbuf, void **data);
 extern int dhd_pktlog_ring_get_writebuf(dhd_pktlog_ring_t *ringbuf, void **data);
 extern int dhd_pktlog_ring_add_pkts(dhd_pub_t *dhdp, void *pkt, void *pktdata, uint32 pktid,
 		uint32 direction);
 extern int dhd_pktlog_ring_tx_status(dhd_pub_t *dhdp, void *pkt, void *pktdata, uint32 pktid,
 		uint16 status);
 extern dhd_pktlog_ring_t* dhd_pktlog_ring_change_size(dhd_pktlog_ring_t *ringbuf, int size);
 extern void dhd_pktlog_filter_pull_forward(dhd_pktlog_filter_t *filter,
 		uint32 del_filter_id, uint32 list_cnt);

 #define PKT_RX 0
 #define PKT_TX 1
 #define PKT_WAKERX 2
 #define DHD_INVALID_PKTID (0U)
 #define PKTLOG_TRANS_TX 0x01
 #define PKTLOG_TRANS_RX 0x02
 #define PKTLOG_TRANS_TXS 0x04

 #define PKTLOG_SET_IN_TX(dhdp) \
 { \
 	do { \
 		OSL_ATOMIC_OR((dhdp)->osh, &(dhdp)->pktlog->pktlog_status, PKTLOG_TRANS_TX); \
 	} while (0); \
 }

 #define PKTLOG_SET_IN_RX(dhdp) \
 { \
 	do { \
 		OSL_ATOMIC_OR((dhdp)->osh, &(dhdp)->pktlog->pktlog_status, PKTLOG_TRANS_RX); \
 	} while (0); \
 }

 #define PKTLOG_SET_IN_TXS(dhdp) \
 { \
 	do { \
 		OSL_ATOMIC_OR((dhdp)->osh, &(dhdp)->pktlog->pktlog_status, PKTLOG_TRANS_TXS); \
 	} while (0); \
 }

 #define PKTLOG_CLEAR_IN_TX(dhdp) \
 { \
 	do { \
 		OSL_ATOMIC_AND((dhdp)->osh, &(dhdp)->pktlog->pktlog_status, ~PKTLOG_TRANS_TX); \
 	} while (0); \
 }

 #define PKTLOG_CLEAR_IN_RX(dhdp) \
 { \
 	do { \
 		OSL_ATOMIC_AND((dhdp)->osh, &(dhdp)->pktlog->pktlog_status, ~PKTLOG_TRANS_RX); \
 	} while (0); \
 }

 #define PKTLOG_CLEAR_IN_TXS(dhdp) \
 { \
 	do { \
 		OSL_ATOMIC_AND((dhdp)->osh, &(dhdp)->pktlog->pktlog_status, ~PKTLOG_TRANS_TXS); \
 	} while (0); \
 }

 #define DHD_PKTLOG_TX(dhdp, pkt, pktdata, pktid) \
 { \
 	do { \
 		if ((dhdp) && (dhdp)->pktlog && (pkt)) { \
 			PKTLOG_SET_IN_TX(dhdp); \
 			if ((dhdp)->pktlog->pktlog_ring && \
 				OSL_ATOMIC_READ((dhdp)->osh, \
 					(&(dhdp)->pktlog->pktlog_ring->start))) { \
 				dhd_pktlog_ring_add_pkts(dhdp, pkt, pktdata, pktid, PKT_TX); \
 			} \
 			PKTLOG_CLEAR_IN_TX(dhdp); \
 		} \
 	} while (0); \
 }

 #define DHD_PKTLOG_TXS(dhdp, pkt, pktdata, pktid, status) \
 { \
 	do { \
 		if ((dhdp) && (dhdp)->pktlog && (pkt)) { \
 			PKTLOG_SET_IN_TXS(dhdp); \
 			if ((dhdp)->pktlog->pktlog_ring && \
 				OSL_ATOMIC_READ((dhdp)->osh, \
 					(&(dhdp)->pktlog->pktlog_ring->start))) { \
 				dhd_pktlog_ring_tx_status(dhdp, pkt, pktdata, pktid, status); \
 			} \
 			PKTLOG_CLEAR_IN_TXS(dhdp); \
 		} \
 	} while (0); \
 }

 #define DHD_PKTLOG_RX(dhdp, pkt, pktdata) \
 { \
 	do { \
 		if ((dhdp) && (dhdp)->pktlog && (pkt)) { \
 			PKTLOG_SET_IN_RX(dhdp); \
 			if (ntoh16((pkt)->protocol) != ETHER_TYPE_BRCM) { \
 				if ((dhdp)->pktlog->pktlog_ring && \
 					OSL_ATOMIC_READ((dhdp)->osh, \
 						(&(dhdp)->pktlog->pktlog_ring->start))) { \
 					dhd_pktlog_ring_add_pkts(dhdp, pkt, pktdata, \
 						DHD_INVALID_PKTID, PKT_RX); \
 				} \
 			} \
 			PKTLOG_CLEAR_IN_RX(dhdp); \
 		} \
 	} while (0); \
 }

 #define DHD_PKTLOG_WAKERX(dhdp, pkt, pktdata) \
 { \
 	do { \
 		if ((dhdp) && (dhdp)->pktlog && (pkt)) { \
 			PKTLOG_SET_IN_RX(dhdp); \
 			if (ntoh16((pkt)->protocol) != ETHER_TYPE_BRCM) { \
 				if ((dhdp)->pktlog->pktlog_ring && \
 					OSL_ATOMIC_READ((dhdp)->osh, \
 						(&(dhdp)->pktlog->pktlog_ring->start))) { \
 					dhd_pktlog_ring_add_pkts(dhdp, pkt, pktdata, \
 						DHD_INVALID_PKTID, PKT_WAKERX); \
 				} \
 			} \
 			PKTLOG_CLEAR_IN_RX(dhdp); \
 		} \
 	} while (0); \
 }

 extern dhd_pktlog_filter_t* dhd_pktlog_filter_init(int size);
 extern int dhd_pktlog_filter_deinit(dhd_pktlog_filter_t *filter);
 extern int dhd_pktlog_filter_add(dhd_pktlog_filter_t *filter, char *arg);
 extern int dhd_pktlog_filter_del(dhd_pktlog_filter_t *filter, char *arg);
 extern int dhd_pktlog_filter_enable(dhd_pktlog_filter_t *filter, uint32 pktlog_case, uint32 enable);
 extern int dhd_pktlog_filter_pattern_enable(dhd_pktlog_filter_t *filter, char *arg, uint32 enable);
 extern int dhd_pktlog_filter_info(dhd_pktlog_filter_t *filter);
 extern bool dhd_pktlog_filter_matched(dhd_pktlog_filter_t *filter, char *data, uint32 pktlog_case);
 extern bool dhd_pktlog_filter_existed(dhd_pktlog_filter_t *filter, char *arg, uint32 *id);

 #define DHD_PKTLOG_FILTER_ADD(pattern, filter_pattern, dhdp)	\
 {	\
 	do {	\
 		if ((strlen(pattern) + 1) < sizeof(filter_pattern)) {	\
 			strncpy(filter_pattern, pattern, sizeof(filter_pattern));	\
 			dhd_pktlog_filter_add(dhdp->pktlog->pktlog_filter, filter_pattern);	\
 		}	\
 	} while (0);	\
 }

 #define DHD_PKTLOG_DUMP_PATH	DHD_COMMON_DUMP_PATH
 extern int dhd_pktlog_debug_dump(dhd_pub_t *dhdp);
 extern void dhd_pktlog_dump(void *handle, void *event_info, u8 event);
 extern void dhd_schedule_pktlog_dump(dhd_pub_t *dhdp);
 extern int dhd_pktlog_dump_write_memory(dhd_pub_t *dhdp, const void *user_buf, uint32 size);
 extern int dhd_pktlog_dump_write_file(dhd_pub_t *dhdp);

 #define DHD_PKTLOG_FATE_INFO_STR_LEN 256
 #define DHD_PKTLOG_FATE_INFO_FORMAT	"BRCM_Packet_Fate"
 #define DHD_PKTLOG_DUMP_TYPE "pktlog_dump"
 #define DHD_PKTLOG_DEBUG_DUMP_TYPE "pktlog_debug_dump"

 extern void dhd_pktlog_get_filename(dhd_pub_t *dhdp, char *dump_path, int len);
 extern uint32 dhd_pktlog_get_item_length(dhd_pktlog_ring_info_t *report_ptr);
 extern uint32 dhd_pktlog_get_dump_length(dhd_pub_t *dhdp);
 extern uint32 __dhd_dbg_pkt_hash(uintptr_t pkt, uint32 pktid);

 #ifdef DHD_COMPACT_PKT_LOG
 #define CPKT_LOG_BIT_SIZE		22
 #define CPKT_LOG_MAX_NUM		80
 extern int dhd_cpkt_log_proc(dhd_pub_t *dhdp, char *buf, int buf_len,
         int bit_offset, int req_pkt_num);
 #endif  /* DHD_COMPACT_PKT_LOG */
 #endif /* DHD_PKT_LOGGING */
 #endif /* __DHD_PKTLOG_H_ */
	/*
	* DHD debugability packet logging header file
	*
	* Copyright (C) 2020, Broadcom.
	*
	* Unless you and Broadcom execute a separate written software license
	* agreement governing use of this software, this software is licensed to you
	* under the terms of the GNU General Public License version 2 (the "GPL"),
	* available at http://www.broadcom.com/licenses/GPLv2.php, with the
	* following added to such license:
	*
	* As a special exception, the copyright holders of this software give you
	* permission to link this software with independent modules, and to copy and
	* distribute the resulting executable under terms of your choice, provided that
	* you also meet, for each linked independent module, the terms and conditions of
	* the license of that module. An independent module is a module which is not
	* derived from this software. The special exception does not apply to any
	* modifications of the software.
	*
	*
	* <<Broadcom-WL-IPTag/Open:>>
	*
	* $Id$
	*/

	#ifndef __DHD_PKTLOG_H_
	#define __DHD_PKTLOG_H_

	#include <dhd_debug.h>
	#include <dhd.h>
	#include <asm/atomic.h>
	#ifdef DHD_COMPACT_PKT_LOG
	#include <linux/rbtree.h>
	#endif /* DHD_COMPACT_PKT_LOG */

	#ifdef DHD_PKT_LOGGING
	#define DHD_PKT_LOG(args) DHD_INFO(args)
	#define DEFAULT_MULTIPLE_PKTLOG_BUF 1
	#ifndef CUSTOM_MULTIPLE_PKTLOG_BUF
	#define CUSTOM_MULTIPLE_PKTLOG_BUF DEFAULT_MULTIPLE_PKTLOG_BUF
	#endif /* CUSTOM_MULTIPLE_PKTLOG_BUF */
	#define MIN_PKTLOG_LEN (32 * 10 * 2 * CUSTOM_MULTIPLE_PKTLOG_BUF)
	#define MAX_PKTLOG_LEN (32 * 10 * 2 * 10)
	#define MAX_DHD_PKTLOG_FILTER_LEN 14
	#define MAX_MASK_PATTERN_FILTER_LEN 64
	#define PKTLOG_TXPKT_CASE 0x0001
	#define PKTLOG_TXSTATUS_CASE 0x0002
	#define PKTLOG_RXPKT_CASE 0x0004
	/* MAX_FILTER_PATTERN_LEN is buf len to print bitmask/pattern with string */
	#define MAX_FILTER_PATTERN_LEN \
	((MAX_MASK_PATTERN_FILTER_LEN * HD_BYTE_SIZE) + HD_PREFIX_SIZE + 1) * 2
	#define PKTLOG_DUMP_BUF_SIZE (64 * 1024)

	typedef struct dhd_dbg_pktlog_info {
	frame_type payload_type;
	size_t pkt_len;
	uint32 driver_ts_sec;
	uint32 driver_ts_usec;
	uint32 firmware_ts;
	uint32 pkt_hash;
	bool direction;
	void *pkt;
	} dhd_dbg_pktlog_info_t;

	typedef struct dhd_pktlog_ring_info
	{
	dll_t p_info; /* list pointer */
	union {
	wifi_tx_packet_fate tx_fate;
	wifi_rx_packet_fate rx_fate;
	uint32 fate;
	};
	dhd_dbg_pktlog_info_t info;
	} dhd_pktlog_ring_info_t;

	typedef struct dhd_pktlog_ring
	{
	dll_t ring_info_head; /* ring_info list */
	dll_t ring_info_free; /* ring_info free list */
	osl_atomic_t start;
	uint32 pktlog_minmize;
	uint32 pktlog_len; /* size of pkts */
	uint32 pktcount;
	spinlock_t *pktlog_ring_lock;
	dhd_pub_t *dhdp;
	dhd_pktlog_ring_info_t ring_info_mem; / ring_info mem pointer */
	} dhd_pktlog_ring_t;

	typedef struct dhd_pktlog_filter_info
	{
	uint32 id;
	uint32 offset;
	uint32 size_bytes; /* Size of pattern. */
	uint32 enable;
	uint8 mask[MAX_MASK_PATTERN_FILTER_LEN];
	uint8 pattern[MAX_MASK_PATTERN_FILTER_LEN];
	} dhd_pktlog_filter_info_t;

	typedef struct dhd_pktlog_filter
	{
	dhd_pktlog_filter_info_t *info;
	uint32 list_cnt;
	uint32 enable;
	} dhd_pktlog_filter_t;

	typedef struct dhd_pktlog
	{
	struct dhd_pktlog_ring *pktlog_ring;
	struct dhd_pktlog_filter *pktlog_filter;
	osl_atomic_t pktlog_status;
	dhd_pub_t *dhdp;
	#ifdef DHD_COMPACT_PKT_LOG
	struct rb_root cpkt_log_tt_rbt;
	#endif /* DHD_COMPACT_PKT_LOG */
	} dhd_pktlog_t;

	typedef struct dhd_pktlog_pcap_hdr
	{
	uint32 magic_number;
	uint16 version_major;
	uint16 version_minor;
	uint16 thiszone;
	uint32 sigfigs;
	uint32 snaplen;
	uint32 network;
	} dhd_pktlog_pcap_hdr_t;

	#define PKTLOG_PCAP_MAGIC_NUM 0xa1b2c3d4
	#define PKTLOG_PCAP_MAJOR_VER 0x02
	#define PKTLOG_PCAP_MINOR_VER 0x04
	#define PKTLOG_PCAP_SNAP_LEN 0x40000
	#define PKTLOG_PCAP_NETWORK_TYPE 147

	extern int dhd_os_attach_pktlog(dhd_pub_t *dhdp);
	extern int dhd_os_detach_pktlog(dhd_pub_t *dhdp);
	extern dhd_pktlog_ring_t* dhd_pktlog_ring_init(dhd_pub_t *dhdp, int size);
	extern int dhd_pktlog_ring_deinit(dhd_pub_t dhdp, dhd_pktlog_ring_t ring);
	extern int dhd_pktlog_ring_set_nextpos(dhd_pktlog_ring_t *ringbuf);
	extern int dhd_pktlog_ring_get_nextbuf(dhd_pktlog_ring_t ringbuf, void *data);
	extern int dhd_pktlog_ring_set_prevpos(dhd_pktlog_ring_t *ringbuf);
	extern int dhd_pktlog_ring_get_prevbuf(dhd_pktlog_ring_t ringbuf, void *data);
	extern int dhd_pktlog_ring_get_writebuf(dhd_pktlog_ring_t ringbuf, void *data);
	extern int dhd_pktlog_ring_add_pkts(dhd_pub_t dhdp, void pkt, void *pktdata, uint32 pktid,
	uint32 direction);
	extern int dhd_pktlog_ring_tx_status(dhd_pub_t dhdp, void pkt, void *pktdata, uint32 pktid,
	uint16 status);
	extern dhd_pktlog_ring_t* dhd_pktlog_ring_change_size(dhd_pktlog_ring_t *ringbuf, int size);
	extern void dhd_pktlog_filter_pull_forward(dhd_pktlog_filter_t *filter,
	uint32 del_filter_id, uint32 list_cnt);

	#define PKT_RX 0
	#define PKT_TX 1
	#define PKT_WAKERX 2
	#define DHD_INVALID_PKTID (0U)
	#define PKTLOG_TRANS_TX 0x01
	#define PKTLOG_TRANS_RX 0x02
	#define PKTLOG_TRANS_TXS 0x04

	#define PKTLOG_SET_IN_TX(dhdp) \
	{ \
	do { \
	OSL_ATOMIC_OR((dhdp)->osh, &(dhdp)->pktlog->pktlog_status, PKTLOG_TRANS_TX); \
	} while (0); \
	}

	#define PKTLOG_SET_IN_RX(dhdp) \
	{ \
	do { \
	OSL_ATOMIC_OR((dhdp)->osh, &(dhdp)->pktlog->pktlog_status, PKTLOG_TRANS_RX); \
	} while (0); \
	}

	#define PKTLOG_SET_IN_TXS(dhdp) \
	{ \
	do { \
	OSL_ATOMIC_OR((dhdp)->osh, &(dhdp)->pktlog->pktlog_status, PKTLOG_TRANS_TXS); \
	} while (0); \
	}

	#define PKTLOG_CLEAR_IN_TX(dhdp) \
	{ \
	do { \
	OSL_ATOMIC_AND((dhdp)->osh, &(dhdp)->pktlog->pktlog_status, ~PKTLOG_TRANS_TX); \
	} while (0); \
	}

	#define PKTLOG_CLEAR_IN_RX(dhdp) \
	{ \
	do { \
	OSL_ATOMIC_AND((dhdp)->osh, &(dhdp)->pktlog->pktlog_status, ~PKTLOG_TRANS_RX); \
	} while (0); \
	}

	#define PKTLOG_CLEAR_IN_TXS(dhdp) \
	{ \
	do { \
	OSL_ATOMIC_AND((dhdp)->osh, &(dhdp)->pktlog->pktlog_status, ~PKTLOG_TRANS_TXS); \
	} while (0); \
	}

	#define DHD_PKTLOG_TX(dhdp, pkt, pktdata, pktid) \
	{ \
	do { \
	if ((dhdp) && (dhdp)->pktlog && (pkt)) { \
	PKTLOG_SET_IN_TX(dhdp); \
	if ((dhdp)->pktlog->pktlog_ring && \
	OSL_ATOMIC_READ((dhdp)->osh, \
	(&(dhdp)->pktlog->pktlog_ring->start))) { \
	dhd_pktlog_ring_add_pkts(dhdp, pkt, pktdata, pktid, PKT_TX); \
	} \
	PKTLOG_CLEAR_IN_TX(dhdp); \
	} \
	} while (0); \
	}

	#define DHD_PKTLOG_TXS(dhdp, pkt, pktdata, pktid, status) \
	{ \
	do { \
	if ((dhdp) && (dhdp)->pktlog && (pkt)) { \
	PKTLOG_SET_IN_TXS(dhdp); \
	if ((dhdp)->pktlog->pktlog_ring && \
	OSL_ATOMIC_READ((dhdp)->osh, \
	(&(dhdp)->pktlog->pktlog_ring->start))) { \
	dhd_pktlog_ring_tx_status(dhdp, pkt, pktdata, pktid, status); \
	} \
	PKTLOG_CLEAR_IN_TXS(dhdp); \
	} \
	} while (0); \
	}

	#define DHD_PKTLOG_RX(dhdp, pkt, pktdata) \
	{ \
	do { \
	if ((dhdp) && (dhdp)->pktlog && (pkt)) { \
	PKTLOG_SET_IN_RX(dhdp); \
	if (ntoh16((pkt)->protocol) != ETHER_TYPE_BRCM) { \
	if ((dhdp)->pktlog->pktlog_ring && \
	OSL_ATOMIC_READ((dhdp)->osh, \
	(&(dhdp)->pktlog->pktlog_ring->start))) { \
	dhd_pktlog_ring_add_pkts(dhdp, pkt, pktdata, \
	DHD_INVALID_PKTID, PKT_RX); \
	} \
	} \
	PKTLOG_CLEAR_IN_RX(dhdp); \
	} \
	} while (0); \
	}

	#define DHD_PKTLOG_WAKERX(dhdp, pkt, pktdata) \
	{ \
	do { \
	if ((dhdp) && (dhdp)->pktlog && (pkt)) { \
	PKTLOG_SET_IN_RX(dhdp); \
	if (ntoh16((pkt)->protocol) != ETHER_TYPE_BRCM) { \
	if ((dhdp)->pktlog->pktlog_ring && \
	OSL_ATOMIC_READ((dhdp)->osh, \
	(&(dhdp)->pktlog->pktlog_ring->start))) { \
	dhd_pktlog_ring_add_pkts(dhdp, pkt, pktdata, \
	DHD_INVALID_PKTID, PKT_WAKERX); \
	} \
	} \
	PKTLOG_CLEAR_IN_RX(dhdp); \
	} \
	} while (0); \
	}

	extern dhd_pktlog_filter_t* dhd_pktlog_filter_init(int size);
	extern int dhd_pktlog_filter_deinit(dhd_pktlog_filter_t *filter);
	extern int dhd_pktlog_filter_add(dhd_pktlog_filter_t filter, char arg);
	extern int dhd_pktlog_filter_del(dhd_pktlog_filter_t filter, char arg);
	extern int dhd_pktlog_filter_enable(dhd_pktlog_filter_t *filter, uint32 pktlog_case, uint32 enable);
	extern int dhd_pktlog_filter_pattern_enable(dhd_pktlog_filter_t filter, char arg, uint32 enable);
	extern int dhd_pktlog_filter_info(dhd_pktlog_filter_t *filter);
	extern bool dhd_pktlog_filter_matched(dhd_pktlog_filter_t filter, char data, uint32 pktlog_case);
	extern bool dhd_pktlog_filter_existed(dhd_pktlog_filter_t filter, char arg, uint32 *id);

	#define DHD_PKTLOG_FILTER_ADD(pattern, filter_pattern, dhdp) \
	{ \
	do { \
	if ((strlen(pattern) + 1) < sizeof(filter_pattern)) { \
	strncpy(filter_pattern, pattern, sizeof(filter_pattern)); \
	dhd_pktlog_filter_add(dhdp->pktlog->pktlog_filter, filter_pattern); \
	} \
	} while (0); \
	}

	#define DHD_PKTLOG_DUMP_PATH DHD_COMMON_DUMP_PATH
	extern int dhd_pktlog_debug_dump(dhd_pub_t *dhdp);
	extern void dhd_pktlog_dump(void handle, void event_info, u8 event);
	extern void dhd_schedule_pktlog_dump(dhd_pub_t *dhdp);
	extern int dhd_pktlog_dump_write_memory(dhd_pub_t dhdp, const void user_buf, uint32 size);
	extern int dhd_pktlog_dump_write_file(dhd_pub_t *dhdp);

	#define DHD_PKTLOG_FATE_INFO_STR_LEN 256
	#define DHD_PKTLOG_FATE_INFO_FORMAT "BRCM_Packet_Fate"
	#define DHD_PKTLOG_DUMP_TYPE "pktlog_dump"
	#define DHD_PKTLOG_DEBUG_DUMP_TYPE "pktlog_debug_dump"

	extern void dhd_pktlog_get_filename(dhd_pub_t dhdp, char dump_path, int len);
	extern uint32 dhd_pktlog_get_item_length(dhd_pktlog_ring_info_t *report_ptr);
	extern uint32 dhd_pktlog_get_dump_length(dhd_pub_t *dhdp);
	extern uint32 __dhd_dbg_pkt_hash(uintptr_t pkt, uint32 pktid);

	#ifdef DHD_COMPACT_PKT_LOG
	#define CPKT_LOG_BIT_SIZE 22
	#define CPKT_LOG_MAX_NUM 80
	extern int dhd_cpkt_log_proc(dhd_pub_t dhdp, char buf, int buf_len,
	int bit_offset, int req_pkt_num);
	#endif /* DHD_COMPACT_PKT_LOG */
	#endif /* DHD_PKT_LOGGING */
	#endif /* __DHD_PKTLOG_H_ */