Merge "qcawifi: Introducing event logger for HTT command/event Tx/Rx"

dp/wifi3.0/dp_htt_logger.c

@@ -0,0 +1,1094 @@
+/*
+ * Copyright (c) 2019 The Linux Foundation. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+#include "qdf_lock.h"
+#include "qdf_debugfs.h"
+#include "qdf_module.h"
+#include "qdf_list.h"
+#include "dp_htt_logger.h"
+
+#define HTT_DBG_FILE_PERM           (QDF_FILE_USR_READ | QDF_FILE_USR_WRITE | \
+					 QDF_FILE_GRP_READ | \
+					 QDF_FILE_OTH_READ)
+/**
+ * HTT_DISPLAY_SIZE   : Supported Number of command/event/wbm_event to be
+ * read at one shot through wdf debugfs framework
+ */
+#define HTT_DISPLAY_SIZE 29
+
+/**
+ * Used for stop_seq
+ * Bit 0: htt_command_log
+ * Bit 1: htt_event_log
+ * Bit 2: htt_wbm_event_log
+ * Bit 3: htt_log_size
+ * Bit 4: htt_enable
+ * Bit 5: htt_cmd_disable_list
+ * Bit 6: htt_event_disable_list
+ * Bit 7: htt_wbm_event_disable_list
+ * Bit 8-15: Reserved
+ */
+#define HTT_COMMAND_LOG_BP         0
+#define HTT_EVENT_LOG_BP           1
+#define HTT_WBM_EVENT_LOG_BP       2
+#define HTT_LOG_SIZE_BP            3
+#define HTT_ENABLE_BP              4
+#define HTT_CMD_DISABLE_LIST_BP    5
+#define HTT_EVENT_DISABLE_LIST     6
+#define HTT_WBM_EVENT_DISABLE_LIST 7
+
+/**
+ * Host messages which needs to be enabled by default
+ *
+ * Note: Below macro definition is cloned from
+ * enum htt_t2h_msg_type fw_hdr/fw/htt.h and any
+ * change in enum htt_t2h_msg_type for below field
+ * will need a change here as well.
+ */
+#define HTT_T2H_MSG_TYPE_PEER_MAP_C       0x3
+#define HTT_T2H_MSG_TYPE_PEER_UNMAP_C     0x4
+#define HTT_T2H_MSG_TYPE_RX_ADDBA_C       0x5
+#define HTT_T2H_MSG_TYPE_RX_DELBA_C       0x6
+#define HTT_T2H_MSG_TYPE_PEER_MAP_V2_C    0x1e
+#define HTT_T2H_MSG_TYPE_PEER_UNMAP_V2_C  0x1f
+
+/**
+ * disable_all_command(): Disable all command
+ * disable_all_event(): Disable all event
+ * enable_event(): Enable specific event
+ */
+#define disable_all_command(htt_logger_handle) \
+	htt_logger_handle->log_info.htt_cmd_disable_list = 0xFFFFFFFFFFFFFFFF
+#define disable_all_event(htt_logger_handle)\
+	htt_logger_handle->log_info.htt_event_disable_list = 0xFFFFFFFFFFFFFFFF
+#define disable_wbm_success_status(htt_logger_handle) \
+	htt_logger_handle->log_info.htt_wbm_event_disable_list = 0x1
+#define enable_htt_logging(htt_logger_handle) \
+	htt_logger_handle->log_info.htt_logging_enable = 1
+#define enable_event(htt_logger_handle, eventid) \
+do { \
+	htt_disable_mask = ~(0x1 << eventid); \
+	htt_logger_handle->log_info.htt_event_disable_list &= \
+		htt_disable_mask; \
+} while (0)
+
+/**
+ * log_buf_init() - Initialize htt buffer
+ */
+static inline void log_buf_init(struct htt_log_buf_t *buf)
+{
+	buf->length = 0;
+	buf->buf_tail_idx = 0;
+	buf->size = HTT_EVENT_DEBUG_MAX_ENTRY;
+}
+
+/**
+ * htt_command_record() - Record Command
+ * @ h - htt logger handle
+ * @ msg_type - Command Id
+ * @ msg_data - Data to be logged
+ */
+int htt_command_record(struct htt_logger *h, uint8_t msg_type,
+		       uint8_t *msg_data)
+{
+	struct htt_command_debug *buf = NULL;
+	uint32_t *p_buf_tail_idx = NULL;
+	uint8_t tdata[HTT_COMMAND_DEBUG_ENTRY_MAX_LENGTH];
+	struct htt_log_buf_t *cmd_log_buf;
+
+	/* return 0 if:
+	 * 1. Initialization failed.
+	 * 2. htt_logging_enable is 0 -> can get disable from file ops
+	 * 3. This specific msg_type is disabled
+	 */
+	if (!h)
+		return 0;
+
+	cmd_log_buf = &h->log_info.htt_command_log_buf_info;
+	if ((0 == h->log_info.htt_logging_enable) ||
+	    ((1 << msg_type) & h->log_info.htt_cmd_disable_list))
+		return 0;
+
+	qdf_spin_lock(&cmd_log_buf->record_lock);
+	if (!msg_data) {
+		/* if msg_data is NULL then fill 0xFF in data field */
+		qdf_mem_set(tdata, HTT_COMMAND_DEBUG_ENTRY_MAX_LENGTH, 0xFF);
+		msg_data = tdata;
+	}
+
+	p_buf_tail_idx = &h->log_info.htt_command_log_buf_info.buf_tail_idx;
+
+	/* rewind pointer index if buffer became full */
+	if (HTT_EVENT_DEBUG_MAX_ENTRY <= *p_buf_tail_idx)
+		*p_buf_tail_idx = 0;
+
+	buf = h->log_info.htt_command_log_buf_info.buf;
+	buf[*p_buf_tail_idx].command = msg_type;
+	qdf_mem_copy(buf[*p_buf_tail_idx].data, msg_data,
+		     HTT_COMMAND_DEBUG_ENTRY_MAX_LENGTH);
+	buf[*p_buf_tail_idx].time = qdf_get_log_timestamp();
+	buf[*p_buf_tail_idx].cpu_id = smp_processor_id();
+
+	(*p_buf_tail_idx)++;
+	h->log_info.htt_command_log_buf_info.length++;
+	qdf_spin_unlock(&cmd_log_buf->record_lock);
+	return 0;
+}
+
+/**
+ * htt_event_record() - Record Event
+ * @ h - htt logger handle
+ * @ msg_type - Event Id
+ * @ msg_data - Data to be logged
+ */
+int htt_event_record(struct htt_logger *h, uint8_t msg_type, uint8_t *msg_data)
+{
+	struct htt_event_debug *buf = NULL;
+	uint32_t *p_buf_tail_idx = NULL;
+	uint8_t tdata[HTT_EVENT_DEBUG_ENTRY_MAX_LENGTH];
+	struct htt_log_buf_t *event_log_buf;
+
+	/* return 0 if:
+	 * 1. Initialization failed.
+	 * 2. htt_logging_enable is 0 -> can get disable from file ops
+	 * 3. This specific msg_type is disabled
+	 */
+	if (!h)
+		return 0;
+
+	event_log_buf = &h->log_info.htt_event_log_buf_info;
+	if ((0 == h->log_info.htt_logging_enable) ||
+	    ((1 << msg_type) & h->log_info.htt_event_disable_list))
+		return 0;
+
+	qdf_spin_lock(&event_log_buf->record_lock);
+	if (!msg_data) {
+		/* if msg_data is NULL then fill 0xFF in data field */
+		qdf_mem_set(tdata, HTT_EVENT_DEBUG_ENTRY_MAX_LENGTH, 0xFF);
+		msg_data = tdata;
+	}
+
+	p_buf_tail_idx = &h->log_info.htt_event_log_buf_info.buf_tail_idx;
+
+	/* rewind pointer index if buffer became full */
+	if (HTT_EVENT_DEBUG_MAX_ENTRY <= *p_buf_tail_idx)
+		*p_buf_tail_idx = 0;
+
+	buf = h->log_info.htt_event_log_buf_info.buf;
+	buf[*p_buf_tail_idx].event = msg_type;
+	qdf_mem_copy(buf[*p_buf_tail_idx].data, msg_data,
+		     HTT_EVENT_DEBUG_ENTRY_MAX_LENGTH);
+	buf[*p_buf_tail_idx].time = qdf_get_log_timestamp();
+	buf[*p_buf_tail_idx].cpu_id = smp_processor_id();
+
+	(*p_buf_tail_idx)++;
+	h->log_info.htt_event_log_buf_info.length++;
+	qdf_spin_unlock(&event_log_buf->record_lock);
+	return 0;
+}
+
+/**
+ * htt_wbm_event_recored() - Record HTT wbm event
+ *
+ * @ h - Pointer for HTT tracer
+ * @ tx_status - Status flag
+ * @ msg_data - Event data
+ */
+int htt_wbm_event_record(struct htt_logger *h, uint8_t tx_status,
+			 uint8_t *msg_data)
+{
+	uint32_t *p_buf_tail_idx = NULL;
+	struct htt_wbm_event_debug *buf = NULL;
+	uint8_t tdata[HTT_WBM_EVENT_DEBUG_ENTRY_MAX_LENGTH];
+	struct htt_log_buf_t *wbm_event_log_buf;
+
+	/* return 0 if:
+	 * 1. Initialization failed.
+	 * 2. htt_logging_enable is 0 -> can get disable from file ops
+	 * 3. This specific tx_status is disabled can be used to disable
+	 *    tx_Status when tx_status is successful.
+	 */
+	if (!h)
+		return 0;
+
+	wbm_event_log_buf = &h->log_info.htt_wbm_event_log_buf_info;
+	if ((0 == h->log_info.htt_logging_enable) ||
+	    ((1 << tx_status) & h->log_info.htt_wbm_event_disable_list))
+		return 0;
+
+	qdf_spin_lock(&wbm_event_log_buf->record_lock);
+	if (!msg_data) {
+		/* if msg_data is NULL then fill 0xFF in data field */
+		qdf_mem_set(tdata, HTT_WBM_EVENT_DEBUG_ENTRY_MAX_LENGTH, 0xFF);
+		msg_data = tdata;
+	}
+
+	p_buf_tail_idx = &h->log_info.htt_wbm_event_log_buf_info.buf_tail_idx;
+	if (HTT_EVENT_DEBUG_MAX_ENTRY <= *p_buf_tail_idx)
+		*p_buf_tail_idx = 0;
+
+	buf = h->log_info.htt_wbm_event_log_buf_info.buf;
+	buf[*p_buf_tail_idx].tx_status = tx_status;
+	qdf_mem_copy(buf[*p_buf_tail_idx].data, msg_data,
+		     HTT_WBM_EVENT_DEBUG_ENTRY_MAX_LENGTH);
+	buf[*p_buf_tail_idx].time = qdf_get_log_timestamp();
+	buf[*p_buf_tail_idx].cpu_id = smp_processor_id();
+
+	(*p_buf_tail_idx)++;
+	h->log_info.htt_wbm_event_log_buf_info.length++;
+	qdf_spin_unlock(&wbm_event_log_buf->record_lock);
+	return 0;
+}
+
+/* debugfs routines */
+/**
+ * debug_htt_command_log_show() - debugfs functions to display content of
+ * command and event buffers. Macro uses max buffer length to display
+ * buffer when it is wraparound.
+ *
+ * @m: qdf_debugfs handler to access htt_logger_handle
+ * @arg: Private data htt_logger_hand here
+ *
+ * Return: Status
+ */
+
+static QDF_STATUS debug_htt_command_log_show(qdf_debugfs_file_t file, void *arg)
+{
+	struct htt_logger *htt_logger_handle = (struct htt_logger *)arg;
+	struct htt_log_buf_t *htt_log = NULL;
+	int pos, nread, i;
+	uint64_t secs, usecs;
+
+	htt_log = &htt_logger_handle->log_info.htt_command_log_buf_info;
+	/* If message already read, return and reset this bit*/
+	/* Bit set to 1 : indicates it is read
+	 * Bit set to 0 : indicates 1st time read
+	 */
+	if ((htt_logger_handle->log_info.stop_seq &
+	    (0x1 << HTT_COMMAND_LOG_BP))) {
+		htt_logger_handle->log_info.stop_seq &=
+			(~(0x1 << HTT_COMMAND_LOG_BP));
+		return QDF_STATUS_SUCCESS;
+	}
+
+	qdf_spin_lock(&htt_logger_handle->log_info.htt_record_lock);
+	if (!htt_log->length) {
+		qdf_spin_unlock(&htt_logger_handle->log_info.htt_record_lock);
+		qdf_debugfs_printf(file,
+				   "no elements to read from ring buffer!\n");
+		/* setting bit sothat in next come we will return in start */
+		htt_logger_handle->log_info.stop_seq |=
+			(0x1 << HTT_COMMAND_LOG_BP);
+		return QDF_STATUS_SUCCESS;
+	}
+
+	if (htt_log->length <= HTT_DISPLAY_SIZE)
+		nread = htt_log->length;
+	else
+		nread = HTT_DISPLAY_SIZE;
+
+	if (htt_log->buf_tail_idx == 0)
+		pos = HTT_DISPLAY_SIZE - 1;
+	else
+		pos = htt_log->buf_tail_idx - 1;
+
+	qdf_debugfs_printf(file, "Length = %d\n", htt_log->length);
+	qdf_spin_unlock(&htt_logger_handle->log_info.htt_record_lock);
+	while (nread--) {
+		struct htt_command_debug *htt_record;
+
+		htt_record = (struct htt_command_debug *)
+		&(((struct htt_command_debug *)htt_log->buf)[pos]);
+		qdf_debugfs_printf(file, "CMD ID = %x\n",
+				   htt_record->command);
+		qdf_debugfs_printf(file, "DATA[0-%d]:",
+				   HTT_COMMAND_DEBUG_ENTRY_MAX_LENGTH - 1);
+		for (i = 0; i < HTT_COMMAND_DEBUG_ENTRY_MAX_LENGTH; i++)
+			qdf_debugfs_printf(file, "%x ", htt_record->data[i]);
+
+		qdf_log_timestamp_to_secs(htt_record->time, &secs, &usecs);
+		qdf_debugfs_printf(file, "\nCPU ID = %d", htt_record->cpu_id);
+		qdf_debugfs_printf(file, "\nCMD TIME = [%llu.%06llu]\n",
+				   secs, usecs);
+
+		if (pos == 0)
+			pos = HTT_DISPLAY_SIZE - 1;
+		else
+			pos--;
+	}
+	htt_logger_handle->log_info.stop_seq |=
+		(0x1 << HTT_COMMAND_LOG_BP);
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS debug_htt_event_log_show(qdf_debugfs_file_t file, void *arg)
+{
+	struct htt_logger *htt_logger_handle = (struct htt_logger *)arg;
+	struct htt_log_buf_t *htt_log = NULL;
+	int pos, nread, i;
+	uint64_t secs, usecs;
+
+	htt_log = &htt_logger_handle->log_info.htt_event_log_buf_info;
+	if ((htt_logger_handle->log_info.stop_seq &
+	    (0x1 << HTT_EVENT_LOG_BP))) {
+		htt_logger_handle->log_info.stop_seq &=
+			(~(0x1 << HTT_EVENT_LOG_BP));
+		return QDF_STATUS_SUCCESS;
+	}
+
+	qdf_spin_lock(&htt_logger_handle->log_info.htt_record_lock);
+	if (!htt_log->length) {
+		qdf_spin_unlock(&htt_logger_handle->log_info.htt_record_lock);
+		qdf_debugfs_printf(file,
+				   "no elements to read from ring buffer!\n");
+		htt_logger_handle->log_info.stop_seq |=
+			(0x1 << HTT_EVENT_LOG_BP);
+		return QDF_STATUS_SUCCESS;
+	}
+
+	if (htt_log->length <= HTT_DISPLAY_SIZE)
+		nread = htt_log->length;
+	else
+		nread = HTT_DISPLAY_SIZE;
+
+	if (htt_log->buf_tail_idx == 0)
+		pos = HTT_DISPLAY_SIZE - 1;
+	else
+		pos = htt_log->buf_tail_idx - 1;
+
+	qdf_debugfs_printf(file, "Length = %d\n", htt_log->length);
+	qdf_spin_unlock(&htt_logger_handle->log_info.htt_record_lock);
+	while (nread--) {
+		struct htt_event_debug *htt_record;
+
+		htt_record = (struct htt_event_debug *)
+		&(((struct htt_event_debug *)htt_log->buf)[pos]);
+		qdf_debugfs_printf(file, "EVENT ID = %x\n", htt_record->event);
+		qdf_debugfs_printf(file, "DATA[0 - %d]:",
+				   HTT_EVENT_DEBUG_ENTRY_MAX_LENGTH - 1);
+		for (i = 0; i < HTT_EVENT_DEBUG_ENTRY_MAX_LENGTH; i++)
+			qdf_debugfs_printf(file, "%x ", htt_record->data[i]);
+
+		qdf_log_timestamp_to_secs(htt_record->time, &secs, &usecs);
+		qdf_debugfs_printf(file, "\nCPU ID = %d", (htt_record->cpu_id));
+		qdf_debugfs_printf(file, "\nEVENT TIME = [%llu.%06llu]\n",
+				   secs, usecs);
+
+		if (pos == 0)
+			pos = HTT_DISPLAY_SIZE - 1;
+		else
+			pos--;
+	}
+	htt_logger_handle->log_info.stop_seq |=
+		(0x1 << HTT_EVENT_LOG_BP);
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS debug_htt_wbm_event_log_show(qdf_debugfs_file_t file,
+					       void *arg)
+{
+	struct htt_logger *htt_logger_handle = (struct htt_logger *)arg;
+	struct htt_log_buf_t *htt_log = NULL;
+	int pos, nread, i;
+	uint64_t secs, usecs;
+
+	htt_log = &htt_logger_handle->log_info.htt_wbm_event_log_buf_info;
+
+	if ((htt_logger_handle->log_info.stop_seq &
+	    (0x1 << HTT_WBM_EVENT_LOG_BP))) {
+		htt_logger_handle->log_info.stop_seq &=
+			(~(0x1 << HTT_WBM_EVENT_LOG_BP));
+		return QDF_STATUS_SUCCESS;
+	}
+
+	qdf_spin_lock(&htt_logger_handle->log_info.htt_record_lock);
+	if (!htt_log->length) {
+		qdf_spin_unlock(&htt_logger_handle->log_info.htt_record_lock);
+		qdf_debugfs_printf(file,
+				   "no elements to read from ring buffer!\n");
+		htt_logger_handle->log_info.stop_seq |=
+			(0x1 << HTT_WBM_EVENT_LOG_BP);
+		return QDF_STATUS_SUCCESS;
+	}
+
+	if (htt_log->length <= HTT_DISPLAY_SIZE)
+		nread = htt_log->length;
+	else
+		nread = HTT_DISPLAY_SIZE;
+
+	if (htt_log->buf_tail_idx == 0)
+		pos = HTT_DISPLAY_SIZE - 1;
+	else
+		pos = htt_log->buf_tail_idx - 1;
+
+	qdf_debugfs_printf(file, "Length = %d\n", htt_log->length);
+	qdf_spin_unlock(&htt_logger_handle->log_info.htt_record_lock);
+	while (nread--) {
+		struct htt_wbm_event_debug *htt_record;
+
+		htt_record = (struct htt_wbm_event_debug *)
+		&(((struct htt_wbm_event_debug *)htt_log->buf)[pos]);
+		qdf_debugfs_printf(file, "WBM Event Tx status =  = %x\n",
+				   htt_record->tx_status);
+		qdf_debugfs_printf(file, "DATA[0-%d]:",
+				   HTT_WBM_EVENT_DEBUG_ENTRY_MAX_LENGTH - 1);
+		for (i = 0; i < HTT_WBM_EVENT_DEBUG_ENTRY_MAX_LENGTH; i++)
+			qdf_debugfs_printf(file, "%x ", htt_record->data[i]);
+
+		qdf_log_timestamp_to_secs(htt_record->time, &secs, &usecs);
+		qdf_debugfs_printf(file, "\nCPU ID = %d", (htt_record->cpu_id));
+		qdf_debugfs_printf(file, "\nWBM EVENT TIME = [%llu.%06llu]\n",
+				   secs, usecs);
+
+		if (pos == 0)
+			pos = HTT_DISPLAY_SIZE - 1;
+		else
+			pos--;
+	}
+
+	htt_logger_handle->log_info.stop_seq |=
+		(0x1 << HTT_WBM_EVENT_LOG_BP);
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * debug_htt_enable_show() - debugfs functions to display enable state of
+ * htt logging feature.
+ *
+ * @file: qdf debugfs handler
+ * @arg: priv data used to get htt_logger_handler
+ *
+ * Return: Status
+ */
+static QDF_STATUS debug_htt_enable_show(qdf_debugfs_file_t file, void *arg)
+{
+	struct htt_logger *htt_logger_handle = (struct htt_logger *)arg;
+	struct htt_debug_log_info *log_info_p = &htt_logger_handle->log_info;
+
+	if ((htt_logger_handle->log_info.stop_seq &
+	    (0x1 << HTT_ENABLE_BP))) {
+		htt_logger_handle->log_info.stop_seq &=
+			(~(0x1 << HTT_ENABLE_BP));
+		return QDF_STATUS_SUCCESS;
+	}
+
+	qdf_debugfs_printf(file, "%d\n",
+			   log_info_p->htt_logging_enable);
+	htt_logger_handle->log_info.stop_seq |=
+		(0x1 << HTT_ENABLE_BP);
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * debug_htt_cmd_disable_list_show() - debugfs functions to display disabled
+ * command id for tracing.
+ *
+ * @file: qdf debugfs handler
+ * @arg: priv data used to get htt_logger_handler
+ *
+ * Return: Status
+ */
+static QDF_STATUS debug_htt_cmd_disable_list_show(qdf_debugfs_file_t file,
+						  void *arg)
+{
+	struct htt_logger *htt_logger_handle = (struct htt_logger *)arg;
+	struct htt_debug_log_info *log_info_p = &htt_logger_handle->log_info;
+
+	if ((htt_logger_handle->log_info.stop_seq &
+	    (0x1 << HTT_CMD_DISABLE_LIST_BP))) {
+		htt_logger_handle->log_info.stop_seq &=
+			(~(0x1 << HTT_CMD_DISABLE_LIST_BP));
+		return QDF_STATUS_SUCCESS;
+	}
+
+	qdf_debugfs_printf(file, "%llu\n",
+			   log_info_p->htt_cmd_disable_list);
+
+	htt_logger_handle->log_info.stop_seq |=
+		(0x1 << HTT_CMD_DISABLE_LIST_BP);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * debug_htt_event_disable_list_show() - debugfs functions to display disabled
+ * event id for tracing.
+ *
+ * @file: qdf debugfs handler
+ * @arg: priv data used to get htt_logger_handler
+ *
+ * Return: Status
+ */
+static QDF_STATUS debug_htt_event_disable_list_show(qdf_debugfs_file_t file,
+						    void *arg)
+{
+	struct htt_logger *htt_logger_handle = (struct htt_logger *)arg;
+	struct htt_debug_log_info *log_info_p = &htt_logger_handle->log_info;
+
+	if ((htt_logger_handle->log_info.stop_seq &
+	    (0x1 << HTT_EVENT_DISABLE_LIST))) {
+		htt_logger_handle->log_info.stop_seq &=
+			(~(0x1 << HTT_EVENT_DISABLE_LIST));
+		return QDF_STATUS_SUCCESS;
+	}
+
+	qdf_debugfs_printf(file, "%llu\n",
+			   log_info_p->htt_event_disable_list);
+
+	htt_logger_handle->log_info.stop_seq |=
+		(0x1 << HTT_EVENT_DISABLE_LIST);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * debug_htt_cmd_disable_list_show() - debugfs functions to display disabled
+ * wbm event id for tracing.
+ *
+ * @file: qdf debugfs handler
+ * @arg: priv data used to get htt_logger_handler
+ *
+ * Return: Status
+ */
+static QDF_STATUS debug_htt_wbm_event_disable_list_show(qdf_debugfs_file_t file
+							, void *arg)
+{
+	struct htt_logger *htt_logger_handle = (struct htt_logger *)arg;
+	struct htt_debug_log_info *log_info_p = &htt_logger_handle->log_info;
+
+	if ((htt_logger_handle->log_info.stop_seq &
+	    (0x1 << HTT_WBM_EVENT_DISABLE_LIST))) {
+		htt_logger_handle->log_info.stop_seq &=
+			(~(0x1 << HTT_WBM_EVENT_DISABLE_LIST));
+		return QDF_STATUS_SUCCESS;
+	}
+
+	qdf_debugfs_printf(file, "%llu\n",
+			   log_info_p->htt_wbm_event_disable_list);
+
+	htt_logger_handle->log_info.stop_seq |=
+		(0x1 << HTT_WBM_EVENT_DISABLE_LIST);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * debug_htt_log_size_show() - debugfs functions to display configured size of
+ * htt logging command/event buffer and management command/event buffer.
+ *
+ * @file: qdf debugfs handler
+ * @arg: priv data used to get htt_logger_handler
+ *
+ * Return: Status
+ */
+static QDF_STATUS debug_htt_log_size_show(qdf_debugfs_file_t file, void *arg)
+{
+	struct htt_logger *htt_logger_handle = (struct htt_logger *)arg;
+
+	if ((htt_logger_handle->log_info.stop_seq &
+	    (0x1 << HTT_LOG_SIZE_BP))) {
+		htt_logger_handle->log_info.stop_seq &=
+			(~(0x1 << HTT_LOG_SIZE_BP));
+
+		return QDF_STATUS_SUCCESS;
+	}
+
+	qdf_debugfs_printf(file, "HTT command/event log max size:%d\n",
+			   HTT_EVENT_DEBUG_MAX_ENTRY);
+
+	htt_logger_handle->log_info.stop_seq |=
+		(0x1 << HTT_LOG_SIZE_BP);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * debug_htt_##func_base##_write() - debugfs functions to clear
+ * htt logging command/event buffer and management command/event buffer.
+ *
+ * @priv: file handler to access htt_logger_handle
+ * @buf: received data buffer
+ * @len: length of received buffer
+ *
+ * Return: Status
+ */
+#define GENERATE_DEBUG_WRITE_FUNCS(func_base, htt_ring_size, htt_record_type) \
+	static QDF_STATUS debug_htt_##func_base##_write(void *priv,           \
+			const char *buf, qdf_size_t len)                      \
+{                                                                             \
+	int k, ret;                                                           \
+	struct htt_logger *htt_logger_handle = (struct htt_logger *)priv;    \
+	struct htt_log_buf_t *htt_log = &htt_logger_handle->log_info.         \
+					htt_##func_base##_buf_info;           \
+	ret = kstrtoint(buf, 0, &k);                                          \
+	if ((ret != 0) || (k != 0)) {                                         \
+		return QDF_STATUS_E_PERM;                                     \
+	}                                                                     \
+	qdf_spin_lock(&htt_logger_handle->log_info.htt_record_lock);          \
+	qdf_mem_zero(htt_log->buf, (htt_ring_size) *                          \
+			sizeof(struct htt_record_type));                      \
+	htt_log->length = 0;                                                  \
+	htt_log->buf_tail_idx = 0;                                       \
+	qdf_spin_unlock(&htt_logger_handle->log_info.htt_record_lock);        \
+	return QDF_STATUS_SUCCESS ;                                           \
+}
+
+GENERATE_DEBUG_WRITE_FUNCS(command_log, HTT_EVENT_DEBUG_MAX_ENTRY,
+			   htt_command_debug);
+GENERATE_DEBUG_WRITE_FUNCS(event_log, HTT_EVENT_DEBUG_MAX_ENTRY,
+			   htt_event_debug);
+GENERATE_DEBUG_WRITE_FUNCS(wbm_event_log, HTT_EVENT_DEBUG_MAX_ENTRY,
+			   htt_wbm_event_debug);
+
+/**
+ * debug_htt_enable_write() - debugfs functions to enable/disable
+ * htt logging feature.
+ *
+ * @priv: file handler to access htt_logger_handle
+ * @buf: received data buffer
+ * @len: length of received buffer
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS debug_htt_enable_write(void *priv, const char *buf,
+					 qdf_size_t len)
+{
+	struct htt_logger *htt_logger_handle = (struct htt_logger *)priv;
+	int k, ret;
+
+	ret = kstrtoint(buf, 0, &k);
+	if ((ret != 1) || ((k != 0) && (k != 1)))
+		return QDF_STATUS_E_PERM;
+
+	htt_logger_handle->log_info.htt_logging_enable = k;
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * debug_htt_cmd_disable_list_write() - Debugfs write for command
+ * to be disabled for tracing
+ * @priv: file handler to access htt_logger_handle
+ * @buf: received data buffer
+ * @len: length of received buffer
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS debug_htt_cmd_disable_list_write(void *priv,
+						   const char *buf,
+						   qdf_size_t len)
+{
+	struct htt_logger *htt_logger_handle = (struct htt_logger *)priv;
+	int ret;
+	uint64_t k;
+
+	ret = kstrtou64(buf, 0, &k);
+	if ((ret != 0) || ((k < 0) || (k > 0xFFFFFFFF)))
+		return QDF_STATUS_E_PERM;
+	htt_logger_handle->log_info.htt_cmd_disable_list = k;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * debug_htt_event_disable_list_write() - Debugfs write for event
+ * to be disabled for tracing
+ * @priv: file handler to access htt_logger_handle
+ * @buf: received data buffer
+ * @len: length of received buffer
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS debug_htt_event_disable_list_write(void *priv,
+						     const char *buf,
+						     qdf_size_t len)
+{
+	struct htt_logger *htt_logger_handle = (struct htt_logger *)priv;
+	int ret;
+	uint64_t k;
+
+	ret = kstrtou64(buf, 0, &k);
+	if ((ret != 0) || ((k < 0) || (k > 0xFFFFFFFF)))
+		return QDF_STATUS_E_PERM;
+
+	htt_logger_handle->log_info.htt_event_disable_list = k;
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * debug_htt_wbm_event_disable_list_write() - Debugfs write for wbm event
+ * to be disabled for tracing
+ * @priv: file handler to access htt_logger_handle
+ * @buf: received data buffer
+ * @len: length of received buffer
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS debug_htt_wbm_event_disable_list_write(void *priv,
+							 const char *buf,
+							 qdf_size_t len)
+{
+	struct htt_logger *htt_logger_handle = (struct htt_logger *)priv;
+	int ret;
+	uint64_t k;
+
+	ret = kstrtou64(buf, 0, &k);
+	if ((ret != 0) || ((k < 0) || (k > 0xFFFFFFFF)))
+		return QDF_STATUS_E_PERM;
+
+	htt_logger_handle->log_info.htt_wbm_event_disable_list = k;
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * debug_htt_log_size_write() - reserved.
+ *
+ * @priv: file handler to access htt_logger_handle
+ * @buf: received data buffer
+ * @len: length of received buffer
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS debug_htt_log_size_write(void *priv,
+					   const char *buf,
+					   qdf_size_t len)
+{
+	return -EINVAL;
+}
+
+/* Structure to maintain debug information */
+struct htt_debugfs_info {
+	const char *name;
+	struct qdf_debugfs_fops *ops;
+};
+
+#define DEBUGFS_FOPS(func_base) { .name = #func_base,               \
+	.ops = &debug_##func_base##_ops }
+
+#define GENERATE_DEBUG_STRUCTS(func_base)                        \
+\
+static struct qdf_debugfs_fops debug_##func_base##_ops = {       \
+	.show           = debug_##func_base##_show,              \
+	.write          = debug_##func_base##_write,             \
+	.priv           = NULL,                                  \
+}
+
+GENERATE_DEBUG_STRUCTS(htt_command_log);
+GENERATE_DEBUG_STRUCTS(htt_event_log);
+GENERATE_DEBUG_STRUCTS(htt_wbm_event_log);
+GENERATE_DEBUG_STRUCTS(htt_enable);
+GENERATE_DEBUG_STRUCTS(htt_log_size);
+GENERATE_DEBUG_STRUCTS(htt_cmd_disable_list);
+GENERATE_DEBUG_STRUCTS(htt_event_disable_list);
+GENERATE_DEBUG_STRUCTS(htt_wbm_event_disable_list);
+
+struct htt_debugfs_info htt_debugfs_infos[NUM_HTT_DEBUG_INFOS] = {
+	DEBUGFS_FOPS(htt_command_log),
+	DEBUGFS_FOPS(htt_event_log),
+	DEBUGFS_FOPS(htt_wbm_event_log),
+	DEBUGFS_FOPS(htt_enable),
+	DEBUGFS_FOPS(htt_log_size),
+	DEBUGFS_FOPS(htt_cmd_disable_list),
+	DEBUGFS_FOPS(htt_event_disable_list),
+	DEBUGFS_FOPS(htt_wbm_event_disable_list),
+};
+
+/**
+ * htt_log_buffer_free() - Free all dynamic allocated buffer memory for
+ * event logging
+ * @htt_logger_handle: HTT handle.
+ *
+ * Return: None
+ */
+static inline void htt_log_buffer_free(struct htt_logger *htt_logger_handle)
+{
+	struct htt_debug_log_info *log_info_p = &htt_logger_handle->log_info;
+
+	/* first disable logging and then free buffer and release lock */
+	log_info_p->htt_logging_enable = 0;
+
+	/* Free allocated buffer */
+	if (log_info_p->htt_command_log_buf_info.buf) {
+		qdf_mem_free(log_info_p->htt_command_log_buf_info.buf);
+		log_info_p->htt_command_log_buf_info.buf = NULL;
+	}
+	if (log_info_p->htt_event_log_buf_info.buf) {
+		qdf_mem_free(log_info_p->htt_event_log_buf_info.buf);
+		log_info_p->htt_event_log_buf_info.buf = NULL;
+	}
+	if (log_info_p->htt_wbm_event_log_buf_info.buf) {
+		qdf_mem_free(log_info_p->htt_wbm_event_log_buf_info.buf);
+		log_info_p->htt_wbm_event_log_buf_info.buf = NULL;
+	}
+}
+
+/**
+ * htt_log_buffer_alloc() - Allocate all dynamic allocated buffer memory for
+ * event logging
+ * @htt_logger_handle: HTT handle.
+ *
+ * Return: None
+ */
+static QDF_STATUS htt_log_buffer_alloc(struct htt_logger *htt_logger_handle)
+{
+	struct htt_log_buf_t *cmd_log_buf;
+	struct htt_log_buf_t *event_log_buf;
+	struct htt_log_buf_t *wbm_event_log_buf;
+
+	cmd_log_buf =
+		&htt_logger_handle->log_info.htt_command_log_buf_info;
+	event_log_buf =
+		&htt_logger_handle->log_info.htt_event_log_buf_info;
+	wbm_event_log_buf =
+		&htt_logger_handle->log_info.htt_wbm_event_log_buf_info;
+
+	/* first disable logging and then free buffer and release lock */
+	htt_logger_handle->log_info.htt_logging_enable = 0;
+
+	/* Allocate data buffer */
+	cmd_log_buf->buf = (struct htt_command_debug *)qdf_mem_malloc(
+				HTT_EVENT_DEBUG_MAX_ENTRY *
+				sizeof(struct htt_command_debug));
+	if (!cmd_log_buf->buf) {
+		HTT_LOGE("Memory allocation for HTT CMD log failed.");
+		goto error_mem_fail;
+	}
+	event_log_buf->buf = (struct htt_event_debug *)qdf_mem_malloc(
+				HTT_EVENT_DEBUG_MAX_ENTRY *
+				sizeof(struct htt_event_debug));
+	if (!event_log_buf->buf) {
+		HTT_LOGE("Memory allocation for HTT EVENT log failed.");
+		goto error_mem_fail;
+	}
+	wbm_event_log_buf->buf = (struct htt_wbm_event_debug *)qdf_mem_malloc(
+					HTT_EVENT_DEBUG_MAX_ENTRY *
+					sizeof(struct htt_wbm_event_debug));
+	if (!wbm_event_log_buf->buf) {
+		HTT_LOGE("Memory allocation for HTT WBM EVENT log failed.");
+		goto error_mem_fail;
+	}
+	return QDF_STATUS_SUCCESS;
+
+error_mem_fail:
+	htt_log_buffer_free(htt_logger_handle);
+	return QDF_STATUS_E_NOMEM;
+}
+
+/**
+ * htt_log_lock_free - Destroy lock
+ */
+static inline void htt_log_lock_alloc(struct htt_logger *htt_logger_handle)
+{
+	struct htt_debug_log_info *log_info_p = &htt_logger_handle->log_info;
+	struct htt_log_buf_t *cmd_log_buf =
+		&htt_logger_handle->log_info.htt_command_log_buf_info;
+	struct htt_log_buf_t *event_log_buf =
+		&htt_logger_handle->log_info.htt_event_log_buf_info;
+	struct htt_log_buf_t *wbm_event_log_buf =
+		&htt_logger_handle->log_info.htt_wbm_event_log_buf_info;
+
+	/* Create lock for cmd/event/wbm */
+	qdf_spinlock_create(&cmd_log_buf->record_lock);
+	qdf_spinlock_create(&event_log_buf->record_lock);
+	qdf_spinlock_create(&wbm_event_log_buf->record_lock);
+
+	/* Create recording lock in read through debugfs */
+	qdf_spinlock_create(&log_info_p->htt_record_lock);
+}
+
+/**
+ * htt_log_lock_free - Destroy lock
+ */
+static inline void htt_log_lock_free(struct htt_logger *htt_logger_handle)
+{
+	struct htt_debug_log_info *log_info_p = &htt_logger_handle->log_info;
+	struct htt_log_buf_t *cmd_log_buf =
+		&htt_logger_handle->log_info.htt_command_log_buf_info;
+	struct htt_log_buf_t *event_log_buf =
+		&htt_logger_handle->log_info.htt_event_log_buf_info;
+	struct htt_log_buf_t *wbm_event_log_buf =
+		&htt_logger_handle->log_info.htt_wbm_event_log_buf_info;
+
+	/* Destroy lock for cmd/event/wbm */
+	qdf_spinlock_destroy(&cmd_log_buf->record_lock);
+	qdf_spinlock_destroy(&event_log_buf->record_lock);
+	qdf_spinlock_destroy(&wbm_event_log_buf->record_lock);
+
+	/* Destroy recording lock in read through debugfs */
+	qdf_spinlock_destroy(&log_info_p->htt_record_lock);
+}
+
+/**
+ * htt_debugfs_remove() - Remove debugfs entry for htt logging.
+ * @htt_logger_handle: htt handle
+ * @dentry: qdf_debugfs directory entry
+ * @id: Index to debug info data array
+ *
+ * Return: none
+ */
+static void htt_debugfs_remove(struct htt_logger *htt_logger_handle)
+{
+	int i;
+	qdf_dentry_t dentry = htt_logger_handle->log_info.htt_log_debugfs_dir;
+
+	if (dentry) {
+		for (i = 0; i < NUM_HTT_DEBUG_INFOS; ++i) {
+			if (htt_logger_handle->debugfs_de[i])
+				htt_logger_handle->debugfs_de[i] = NULL;
+		}
+	}
+
+	if (dentry)
+		qdf_debugfs_remove_dir_recursive(dentry);
+}
+
+/**
+ * htt_debugfs_init() - debugfs functions to create debugfs directory and to
+ * create debugfs enteries.
+ *
+ * @ htt_logger_handle: htt logger handler
+ *
+ * Return: init status
+ */
+
+static QDF_STATUS htt_debugfs_init(struct htt_logger *htt_logger_handle)
+{
+	char buf[32];
+	int i;
+
+	snprintf(buf, sizeof(buf), "HTT_SOC_LOGGER");
+
+	htt_logger_handle->log_info.htt_log_debugfs_dir =
+		qdf_debugfs_create_dir(buf, NULL);
+
+	if (!htt_logger_handle->log_info.htt_log_debugfs_dir) {
+		HTT_LOGE("error while creating debugfs dir for %s", buf);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	for (i = 0; i < NUM_HTT_DEBUG_INFOS; ++i) {
+		htt_debugfs_infos[i].ops->priv = htt_logger_handle;
+		htt_logger_handle->debugfs_de[i] = qdf_debugfs_create_file(
+				htt_debugfs_infos[i].name, HTT_DBG_FILE_PERM,
+				htt_logger_handle->log_info.htt_log_debugfs_dir,
+				htt_debugfs_infos[i].ops);
+
+		if (!htt_logger_handle->debugfs_de[i])
+			goto out;
+	}
+
+	return QDF_STATUS_SUCCESS;
+out:
+	HTT_LOGE("debug Entry creation failed[%s]!", htt_debugfs_infos[i].name);
+	htt_debugfs_remove(htt_logger_handle);
+	return QDF_STATUS_E_FAILURE;
+}
+
+/**
+ * htt_interface_logging_init() - Initialize HTT tracer
+ * @ htt_logger_handle: htt logger handler
+ */
+void htt_interface_logging_init(struct htt_logger **phtt_logger_handle)
+{
+	QDF_STATUS ret;
+	struct htt_logger *htt_logger_handle;
+	struct htt_log_buf_t *cmd_log_buf;
+	struct htt_log_buf_t *event_log_buf;
+	struct htt_log_buf_t *wbm_event_log_buf;
+	uint64_t htt_disable_mask;
+
+	*phtt_logger_handle = (struct htt_logger *)qdf_mem_malloc(
+				sizeof(struct htt_logger));
+	if (!*phtt_logger_handle) {
+		HTT_LOGE("Memory allocation for HTT logger buffer failed.");
+		return;
+	}
+	/* Allocate Buffer */
+	if (QDF_STATUS_SUCCESS != htt_log_buffer_alloc(*phtt_logger_handle)) {
+		qdf_mem_free(*phtt_logger_handle);
+		*phtt_logger_handle = NULL;
+		return;
+	}
+	htt_logger_handle = *phtt_logger_handle;
+	cmd_log_buf =
+		&htt_logger_handle->log_info.htt_command_log_buf_info;
+	event_log_buf =
+		&htt_logger_handle->log_info.htt_event_log_buf_info;
+	wbm_event_log_buf =
+		&htt_logger_handle->log_info.htt_wbm_event_log_buf_info;
+
+	/* Initialize HTT Cmd/Event/WBM Event */
+	log_buf_init(cmd_log_buf);
+	log_buf_init(event_log_buf);
+	log_buf_init(wbm_event_log_buf);
+
+	/* Disable all command */
+	disable_all_command(htt_logger_handle);
+
+	/* Disable all event except:
+	 * HTT_T2H_MSG_TYPE_PEER_MAP, HTT_T2H_MSG_TYPE_PEER_UNMAP
+	 * HTT_T2H_MSG_TYPE_RX_ADDBA HTT_T2H_MSG_TYPE_RX_DELBA
+	 * HTT_T2H_MSG_TYPE_PEER_MAP_V2 HTT_T2H_MSG_TYPE_PEER_UNMAP_V2
+	 */
+	disable_all_event(htt_logger_handle);
+	enable_event(htt_logger_handle, HTT_T2H_MSG_TYPE_PEER_MAP_C);
+	enable_event(htt_logger_handle, HTT_T2H_MSG_TYPE_PEER_UNMAP_C);
+	enable_event(htt_logger_handle, HTT_T2H_MSG_TYPE_RX_ADDBA_C);
+	enable_event(htt_logger_handle, HTT_T2H_MSG_TYPE_RX_DELBA_C);
+	enable_event(htt_logger_handle, HTT_T2H_MSG_TYPE_PEER_MAP_V2_C);
+	enable_event(htt_logger_handle, HTT_T2H_MSG_TYPE_PEER_UNMAP_V2_C);
+
+	/* Disable success status*/
+	disable_wbm_success_status(htt_logger_handle);
+	/* Create lock for all event */
+	htt_log_lock_alloc(htt_logger_handle);
+
+	/* Enable HTT logging */
+	enable_htt_logging(htt_logger_handle);
+
+	ret = htt_debugfs_init(*phtt_logger_handle);
+	if (QDF_STATUS_SUCCESS != ret)
+		goto debugfs_init_failed;
+	return;
+
+debugfs_init_failed:
+	htt_log_buffer_free(*phtt_logger_handle);
+	htt_log_lock_free(*phtt_logger_handle);
+	(*phtt_logger_handle)->log_info.htt_logging_enable = 0;
+	qdf_mem_free(*phtt_logger_handle);
+	*phtt_logger_handle = NULL;
+}
+
+/**
+ * htt_interface_logging_deinit() - Deinitialize HTT tracer
+ * @ htt_logger_handle: htt logger handler
+ */
+void htt_interface_logging_deinit(struct htt_logger *htt_logger_handle)
+{
+	/**
+	 * This case will hit in deinit path
+	 *   if htt_initialization failed
+	 */
+	if (!htt_logger_handle)
+		return;
+	htt_debugfs_remove(htt_logger_handle);
+	htt_log_buffer_free(htt_logger_handle);
+	htt_log_lock_free(htt_logger_handle);
+	qdf_mem_free(htt_logger_handle);
+}

dp/wifi3.0/dp_htt_logger.h

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2019 The Linux Foundation. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _HTT_EVENT_LOGGING__
+#define _HTT_EVENT_LOGGING__
+
+#ifndef HTT_EVENT_DEBUG_MAX_ENTRY
+#define HTT_EVENT_DEBUG_MAX_ENTRY (1024)
+#endif
+
+#define HTT_EVENT_DEBUG_ENTRY_MAX_LENGTH (32)
+#define HTT_COMMAND_DEBUG_ENTRY_MAX_LENGTH (32)
+#define HTT_WBM_EVENT_DEBUG_ENTRY_MAX_LENGTH (32)
+#define NUM_HTT_DEBUG_INFOS 8
+
+#define HTT_LOGD(args ...) \
+	QDF_TRACE(QDF_MODULE_ID_HTT, QDF_TRACE_LEVEL_DEBUG, ## args)
+#define HTT_LOGI(args ...) \
+	QDF_TRACE(QDF_MODULE_ID_HTT, QDF_TRACE_LEVEL_INFO, ## args)
+#define HTT_LOGW(args ...) \
+	QDF_TRACE(QDF_MODULE_ID_HTT, QDF_TRACE_LEVEL_WARN, ## args)
+#define HTT_LOGE(args ...) \
+	QDF_TRACE(QDF_MODULE_ID_HTT, QDF_TRACE_LEVEL_ERROR, ## args)
+#define HTT_LOGP(args ...) \
+	QDF_TRACE(QDF_MODULE_ID_HTT, QDF_TRACE_LEVEL_FATAL, ## args)
+
+/**
+ * struct htt_command_debug - HTT command log buffer data type
+ * @ command - Store HTT MSG id
+ * @ data - vdevid,peerid
+ * @ time - Time of HTT command handling
+ * @ cpu_id - Cpu number which handles cmd/event
+ */
+struct htt_command_debug {
+	uint8_t command;
+	uint8_t data[HTT_COMMAND_DEBUG_ENTRY_MAX_LENGTH];
+	uint64_t time;
+	uint8_t cpu_id;
+};
+
+/**
+ * struct htt_event_debug - HTT event log buffer data type
+ * @ event - Store HTT event id
+ * @ data - vdevid,peerid
+ * @ time - Time of HTT event handling
+ * @ cpu_id - Cpu number which handles cmd/event
+ */
+struct htt_event_debug {
+	uint8_t event;
+	uint8_t data[HTT_EVENT_DEBUG_ENTRY_MAX_LENGTH];
+	uint64_t time;
+	uint8_t cpu_id;
+};
+
+/**
+ * struct htt_wbm_event_debug - HTT wbm event log buffer data type
+ * @ tx_status  - Status
+ * @ data - msg data(peer_id,tid..)
+ * @ time - Time of HTT event handling
+ * @ cpu_id - Cpu number which handles cmd/event
+ */
+struct htt_wbm_event_debug {
+	uint8_t tx_status;
+	uint8_t data[HTT_WBM_EVENT_DEBUG_ENTRY_MAX_LENGTH];
+	uint64_t time;
+	uint8_t cpu_id;
+};
+
+/**
+ * struct htt_log_buf_t - HTT log buffer information type
+ * @buf - Refernce to HTT log buffer
+ * @ length - total count of command/event logged
+ * @ buf_tail_idx - Tail index of buffer
+ * @ size - the size of the buffer in number of entries
+ * @record_lock - Lock HTT recording separate for all cmd/event/wbm
+ */
+struct htt_log_buf_t {
+	void *buf;
+	uint32_t length;
+	uint32_t buf_tail_idx;
+	uint32_t size;
+
+	qdf_spinlock_t record_lock;
+};
+
+/**
+ * struct htt_debug_log_info - Meta data to hold information of
+ *                             all buffers used for HTT logging
+ * @htt_command_log_buf_info - Buffer info for HTT Command log
+ * @htt_event_log_buf_info - Buffer info for HTT Event log
+ * @htt_wbm_event_log_buf_info - Buffer info for HTT wbm event log
+ * @htt_record_lock - Lock HTT recording (while reading through debugfs)
+ * @htt_logging_enable - Enable/Disable state for HTT logging
+ * @htt_cmd_disable_list - Enable/Disable logging for some
+ *                           specific cmd(BitMap)
+ * @htt_event_disable_list - Enable/Disable logging for some
+ *                           specific Event(BitMap)
+ * @htt_wbm_event_disable_list - Enable/Disable logging for
+ *                           some specific wbm event(BitMap)
+ * @stop_seq - Used for read ack.
+ *      stop read sequence once done.
+ *      qdf_debugfs show calls .show function ptr iteratively
+ *      and hence we need to explicitly stop after one call.
+ *      1 bit is used for one fops show call.
+ *      Default all is set to 0.
+ * @htt_log_debugfs_dir - refernce to debugfs directory
+ */
+struct htt_debug_log_info {
+	struct htt_log_buf_t htt_command_log_buf_info;
+	struct htt_log_buf_t htt_event_log_buf_info;
+	struct htt_log_buf_t htt_wbm_event_log_buf_info;
+
+	qdf_spinlock_t htt_record_lock;
+	bool htt_logging_enable;
+	uint64_t htt_cmd_disable_list;
+	uint64_t htt_event_disable_list;
+	uint64_t htt_wbm_event_disable_list;
+	uint16_t stop_seq;
+	qdf_dentry_t htt_log_debugfs_dir;
+};
+
+/**
+ * @ debugfs_de - Dentry for each debugfs exported entry
+ * @log_info - Data for all commad/event
+ */
+struct htt_logger {
+	qdf_dentry_t debugfs_de[NUM_HTT_DEBUG_INFOS];
+	struct htt_debug_log_info log_info;
+};
+
+/**
+ * htt_interface_logging_init() - Initialize HTT event tracer
+ *
+ * @ htt_logger_handle - Pointer for HTT tracer
+ */
+void htt_interface_logging_init(struct htt_logger **htt_logger_handle);
+
+/**
+ * htt_interface_logging_deinit() - Deinitialize HTT event tracer
+ *
+ * @ htt_logger_handle - Pointer for HTT tracer
+ */
+void htt_interface_logging_deinit(struct htt_logger *htt_logger_handle);
+
+/**
+ * htt_command_recored() - Record HTT command
+ *
+ * @ h - Pointer for HTT tracer
+ * @ msg_type - Message type to be logged
+ * @ msg_data - Data to be logged
+ */
+int htt_command_record(struct htt_logger *h, uint8_t msg_type,
+		       uint8_t *msg_data);
+
+/**
+ * htt_event_recored() - Record HTT event
+ *
+ * @ h - Pointer for HTT tracer
+ * @ msg_type - Message type to be logged
+ * @ msg_data - Data to be logged
+ */
+int htt_event_record(struct htt_logger *h, uint8_t msg_type,
+		     uint8_t *msg_data);
+
+/**
+ * htt_wbm_event_recored() - Record HTT wbm event
+ *
+ * @ h - Pointer for HTT tracer
+ * @ tx_status - Status flag
+ * @ msg_data - Data to be logged
+ */
+int htt_wbm_event_record(struct htt_logger *h, uint8_t tx_status,
+			 uint8_t *msg_data);
+
+#endif /* _HTT_EVENT_LOGGING__ */