qcacmn: Add core\utils directory and files to qcacmn

As a part of UMAC convergence, move the core\utils logging to qcacmn.

CRs-Fixed: 1109855
Change-Id: I499a392f74f3e52e99df4d03e4a27bce6cf5be7c

utils/pktlog/include/pktlog.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2013-2014, 2017 The Linux Foundation. All rights reserved.
+ *
+ * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
+ *
+ *
+ * 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.
+ */
+
+/*
+ * This file was originally distributed by Qualcomm Atheros, Inc.
+ * under proprietary terms before Copyright ownership was assigned
+ * to the Linux Foundation.
+ */
+
+#ifndef _PKTLOG_
+#define _PKTLOG_
+#ifndef REMOVE_PKT_LOG
+
+/**
+ * @typedef ol_pktlog_dev_handle
+ * @brief opaque handle for pktlog device object
+ */
+struct ol_pktlog_dev_t;
+typedef struct ol_pktlog_dev_t *ol_pktlog_dev_handle;
+#endif /* #ifndef REMOVE_PKT_LOG */
+#endif /* _PKTLOG_ */

utils/pktlog/include/pktlog_ac.h

@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2012-2017 The Linux Foundation. All rights reserved.
+ *
+ * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
+ *
+ *
+ * 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.
+ */
+
+/*
+ * This file was originally distributed by Qualcomm Atheros, Inc.
+ * under proprietary terms before Copyright ownership was assigned
+ * to the Linux Foundation.
+ */
+
+#ifndef _PKTLOG_AC_H_
+#define _PKTLOG_AC_H_
+#ifndef REMOVE_PKT_LOG
+
+#include "ol_if_athvar.h"
+#include <pktlog_ac_api.h>
+#include <pktlog_ac_fmt.h>
+#include "osdep.h"
+#include <wmi_unified.h>
+#include <wmi_unified_api.h>
+#include <wdi_event_api.h>
+#include "hif.h"
+
+#define NO_REG_FUNCS    4
+
+/* Locking interface for pktlog */
+#define PKTLOG_LOCK_INIT(_pl_info)      spin_lock_init(&(_pl_info)->log_lock)
+#define PKTLOG_LOCK_DESTROY(_pl_info)
+#define PKTLOG_LOCK(_pl_info)           spin_lock(&(_pl_info)->log_lock)
+#define PKTLOG_UNLOCK(_pl_info)         spin_unlock(&(_pl_info)->log_lock)
+
+#define PKTLOG_MODE_SYSTEM      1
+#define PKTLOG_MODE_ADAPTER     2
+
+/*
+ * The proc entry starts with magic number and version field which will be
+ * used by post processing scripts. These fields are not needed by applications
+ * that do not use these scripts. This is skipped using the offset value.
+ */
+#define PKTLOG_READ_OFFSET    8
+
+/* Opaque softc */
+struct ol_ath_generic_softc_t;
+typedef struct ol_ath_generic_softc_t *ol_ath_generic_softc_handle;
+extern void pktlog_disable_adapter_logging(struct hif_opaque_softc *scn);
+extern int pktlog_alloc_buf(struct hif_opaque_softc *scn);
+extern void pktlog_release_buf(ol_txrx_pdev_handle pdev_txrx_handle);
+
+ssize_t pktlog_read_proc_entry(char *buf, size_t nbytes, loff_t *ppos,
+		struct ath_pktlog_info *pl_info, bool *read_complete);
+int pktlog_send_per_pkt_stats_to_user(void);
+A_STATUS
+wdi_pktlog_unsubscribe(struct ol_txrx_pdev_t *txrx_pdev, uint32_t log_state);
+
+struct ol_pl_arch_dep_funcs {
+	void (*pktlog_init)(struct hif_opaque_softc *scn);
+	int (*pktlog_enable)(struct hif_opaque_softc *scn, int32_t log_state,
+			     bool ini, uint8_t user,
+			     uint32_t is_iwpriv_command);
+	int (*pktlog_setsize)(struct hif_opaque_softc *scn, int32_t log_state);
+	int (*pktlog_disable)(struct hif_opaque_softc *scn);
+};
+
+struct ol_pl_os_dep_funcs {
+	int (*pktlog_attach)(struct hif_opaque_softc *scn);
+	void (*pktlog_detach)(struct ol_txrx_pdev_t *handle);
+
+};
+
+struct ath_pktlog_wmi_params {
+	WMI_PKTLOG_EVENT pktlog_event;
+	WMI_CMD_ID cmd_id;
+	bool ini_triggered;
+	uint8_t user_triggered;
+};
+
+extern struct ol_pl_arch_dep_funcs ol_pl_funcs;
+extern struct ol_pl_os_dep_funcs *g_ol_pl_os_dep_funcs;
+
+/* Pktlog handler to save the state of the pktlogs */
+struct ol_pktlog_dev_t {
+	struct ol_pl_arch_dep_funcs *pl_funcs;
+	struct ath_pktlog_info *pl_info;
+	ol_ath_generic_softc_handle scn;
+	char *name;
+	bool tgt_pktlog_alloced;
+	bool is_pktlog_cb_subscribed;
+	bool mt_pktlog_enabled;
+	uint32_t htc_err_cnt;
+	uint8_t htc_endpoint;
+	void *htc_pdev;
+	bool vendor_cmd_send;
+};
+
+#define PKTLOG_SYSCTL_SIZE      14
+#define PKTLOG_MAX_SEND_QUEUE_DEPTH 64
+
+/*
+ * Linux specific pktlog state information
+ */
+struct ath_pktlog_info_lnx {
+	struct ath_pktlog_info info;
+	struct ctl_table sysctls[PKTLOG_SYSCTL_SIZE];
+	struct proc_dir_entry *proc_entry;
+	struct ctl_table_header *sysctl_header;
+};
+
+#define PL_INFO_LNX(_pl_info)   ((struct ath_pktlog_info_lnx *)(_pl_info))
+
+extern struct ol_pktlog_dev_t ol_pl_dev;
+
+/*
+ * WDI related data and functions
+ * Callback function to the WDI events
+ */
+void pktlog_callback(void *pdev, enum WDI_EVENT event, void *log_data);
+
+void pktlog_init(struct hif_opaque_softc *scn);
+int pktlog_enable(struct hif_opaque_softc *scn, int32_t log_state,
+		 bool, uint8_t, uint32_t);
+int pktlog_setsize(struct hif_opaque_softc *scn, int32_t log_state);
+int pktlog_disable(struct hif_opaque_softc *scn);
+int pktlogmod_init(void *context);
+void pktlogmod_exit(struct ol_txrx_pdev_t *handle);
+int pktlog_htc_attach(void);
+void pktlog_process_fw_msg(uint32_t *msg_word);
+
+#define ol_pktlog_attach(_scn)			\
+	do {					\
+		if (g_ol_pl_os_dep_funcs) {	\
+			g_ol_pl_os_dep_funcs->pktlog_attach(_scn);	\
+		}				\
+	} while (0)
+
+#define ol_pktlog_detach(_scn)			\
+	do {					\
+		if (g_ol_pl_os_dep_funcs) {	\
+			g_ol_pl_os_dep_funcs->pktlog_detach(_scn);	\
+		}				\
+	} while (0)
+
+#else                           /* REMOVE_PKT_LOG */
+#define ol_pktlog_attach(_scn)  ({ (void)_scn; })
+#define ol_pktlog_detach(_scn)  ({ (void)_scn; })
+static inline void pktlog_init(struct hif_opaque_softc *scn)
+{
+	return;
+}
+static int pktlog_enable(struct hif_opaque_softc *scn, int32_t log_state,
+			 bool ini, uint8_t user, uint32_t is_iwpriv_command)
+{
+	return 0;
+}
+static int pktlog_setsize(struct hif_opaque_softc *scn, int32_t log_state)
+{
+	return 0;
+}
+static int pktlog_disable(struct hif_opaque_softc *scn)
+{
+	return 0;
+}
+static inline int pktlog_htc_attach(void)
+{
+	return 0;
+}
+static inline void pktlog_process_fw_msg(uint32_t *msg_word)
+{ }
+#endif /* REMOVE_PKT_LOG */
+#endif /* _PKTLOG_AC_H_ */

utils/pktlog/include/pktlog_ac_api.h

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2012-2014, 2016-2017 The Linux Foundation. All rights reserved.
+ *
+ * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
+ *
+ *
+ * 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.
+ */
+
+/*
+ * This file was originally distributed by Qualcomm Atheros, Inc.
+ * under proprietary terms before Copyright ownership was assigned
+ * to the Linux Foundation.
+ */
+
+/*
+ *  The file is used to define structures that are shared between
+ *  kernel space and user space pktlog application.
+ */
+
+#ifndef _PKTLOG_AC_API_
+#define _PKTLOG_AC_API_
+#ifndef REMOVE_PKT_LOG
+
+/**
+ * @typedef ol_pktlog_dev_handle
+ * @brief opaque handle for pktlog device object
+ */
+struct ol_pktlog_dev_t;
+typedef struct ol_pktlog_dev_t *ol_pktlog_dev_handle;
+
+/**
+ * @typedef hif_opaque_softc_handle
+ * @brief opaque handle for hif_opaque_softc
+ */
+struct hif_opaque_softc;
+typedef struct hif_opaque_softc *hif_opaque_softc_handle;
+
+/**
+ * @typedef net_device_handle
+ * @brief opaque handle linux phy device object
+ */
+struct net_device;
+typedef struct net_device *net_device_handle;
+
+void ol_pl_sethandle(ol_pktlog_dev_handle *pl_handle,
+		     hif_opaque_softc_handle scn);
+
+/* Packet log state information */
+#ifndef _PKTLOG_INFO
+#define _PKTLOG_INFO
+struct ath_pktlog_info {
+	struct ath_pktlog_buf *buf;
+	uint32_t log_state;
+	uint32_t saved_state;
+	uint32_t options;
+
+	/* Size of buffer in bytes */
+	int32_t buf_size;
+	spinlock_t log_lock;
+
+	/* Threshold of TCP SACK packets for triggered stop */
+	int sack_thr;
+
+	/* # of tail packets to log after triggered stop */
+	int tail_length;
+
+	/* throuput threshold in bytes for triggered stop */
+	uint32_t thruput_thresh;
+
+	/* (aggregated or single) packet size in bytes */
+	uint32_t pktlen;
+
+	/* a temporary variable for counting TX throughput only */
+	/* PER threshold for triggered stop, 10 for 10%, range [1, 99] */
+	uint32_t per_thresh;
+
+	/* Phyerr threshold for triggered stop */
+	uint32_t phyerr_thresh;
+
+	/* time period for counting trigger parameters, in milisecond */
+	uint32_t trigger_interval;
+	uint32_t start_time_thruput;
+	uint32_t start_time_per;
+};
+#endif /* _PKTLOG_INFO */
+#else                           /* REMOVE_PKT_LOG */
+typedef void *ol_pktlog_dev_handle;
+#define ol_pl_sethandle(pl_handle, scn)	\
+	do {				\
+		(void)pl_handle;	\
+		(void)scn;		\
+	} while (0)
+
+#define ol_pl_set_name(dev)	\
+	do {				\
+		(void)scn;		\
+		(void)dev;		\
+	} while (0)
+
+#endif /* REMOVE_PKT_LOG */
+#endif /* _PKTLOG_AC_API_ */

utils/pktlog/include/pktlog_ac_i.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2012-2017 The Linux Foundation. All rights reserved.
+ *
+ * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
+ *
+ *
+ * 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.
+ */
+
+/*
+ * This file was originally distributed by Qualcomm Atheros, Inc.
+ * under proprietary terms before Copyright ownership was assigned
+ * to the Linux Foundation.
+ */
+
+#ifndef _PKTLOG_AC_I_
+#define _PKTLOG_AC_I_
+#ifndef REMOVE_PKT_LOG
+
+#include <ol_txrx_internal.h>
+#include <pktlog_ac.h>
+
+#ifdef FEATURE_PKTLOG
+#define PKTLOG_DEFAULT_BUFSIZE          (10 * 1024 * 1024) /* 10MB */
+#else
+#define PKTLOG_DEFAULT_BUFSIZE          (1 * 1024 * 1024) /* 1MB */
+#endif
+#define PKTLOG_DEFAULT_SACK_THR         3
+#define PKTLOG_DEFAULT_TAIL_LENGTH      100
+#define PKTLOG_DEFAULT_THRUPUT_THRESH   (64 * 1024)
+#define PKTLOG_DEFAULT_PER_THRESH       30
+#define PKTLOG_DEFAULT_PHYERR_THRESH    300
+#define PKTLOG_DEFAULT_TRIGGER_INTERVAL 500
+struct ath_pktlog_arg {
+	struct ath_pktlog_info *pl_info;
+	uint32_t flags;
+	uint16_t missed_cnt;
+#ifdef HELIUMPLUS
+	uint8_t log_type;
+	uint8_t macId;
+#else
+	uint16_t log_type;
+#endif
+	size_t log_size;
+	uint16_t timestamp;
+#ifdef HELIUMPLUS
+	uint32_t type_specific_data;
+#endif
+	char *buf;
+};
+
+void pktlog_getbuf_intsafe(struct ath_pktlog_arg *plarg);
+char *pktlog_getbuf(struct ol_pktlog_dev_t *pl_dev,
+		    struct ath_pktlog_info *pl_info,
+		    size_t log_size, struct ath_pktlog_hdr *pl_hdr);
+
+A_STATUS process_tx_info(struct ol_txrx_pdev_t *pdev, void *data);
+A_STATUS process_rx_info(void *pdev, void *data);
+A_STATUS process_rx_info_remote(void *pdev, void *data);
+A_STATUS process_rate_find(void *pdev, void *data);
+A_STATUS process_rate_update(void *pdev, void *data);
+A_STATUS process_sw_event(void *pdev, void *data);
+
+
+#endif /* REMOVE_PKT_LOG */
+#endif

utils/pktlog/linux_ac.c

@@ -0,0 +1,931 @@
+/*
+ * Copyright (c) 2012-2017 The Linux Foundation. All rights reserved.
+ *
+ * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
+ *
+ *
+ * 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.
+ */
+
+/*
+ * This file was originally distributed by Qualcomm Atheros, Inc.
+ * under proprietary terms before Copyright ownership was assigned
+ * to the Linux Foundation.
+ */
+
+#ifndef REMOVE_PKT_LOG
+#ifndef EXPORT_SYMTAB
+#define EXPORT_SYMTAB
+#endif
+#ifndef __KERNEL__
+#define __KERNEL__
+#endif
+/*
+ * Linux specific implementation of Pktlogs for 802.11ac
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/vmalloc.h>
+#include <linux/proc_fs.h>
+#include <pktlog_ac_i.h>
+#include <pktlog_ac_fmt.h>
+#include <pktlog_ac.h>
+#include "i_host_diag_core_log.h"
+#include "host_diag_core_log.h"
+#include "ani_global.h"
+
+#define PKTLOG_TAG              "ATH_PKTLOG"
+#define PKTLOG_DEVNAME_SIZE     32
+#define MAX_WLANDEV             1
+
+#ifdef MULTI_IF_NAME
+#define PKTLOG_PROC_DIR         "ath_pktlog" MULTI_IF_NAME
+#else
+#define PKTLOG_PROC_DIR         "ath_pktlog"
+#endif
+
+/* Permissions for creating proc entries */
+#define PKTLOG_PROC_PERM        0444
+#define PKTLOG_PROCSYS_DIR_PERM 0555
+#define PKTLOG_PROCSYS_PERM     0644
+
+#ifndef __MOD_INC_USE_COUNT
+#define PKTLOG_MOD_INC_USE_COUNT	do {			\
+	if (!try_module_get(THIS_MODULE)) {			\
+		printk(KERN_WARNING "try_module_get failed\n");	\
+	} } while (0)
+
+#define PKTLOG_MOD_DEC_USE_COUNT        module_put(THIS_MODULE)
+#else
+#define PKTLOG_MOD_INC_USE_COUNT        MOD_INC_USE_COUNT
+#define PKTLOG_MOD_DEC_USE_COUNT        MOD_DEC_USE_COUNT
+#endif
+
+static struct ath_pktlog_info *g_pktlog_info;
+
+static struct proc_dir_entry *g_pktlog_pde;
+
+static int pktlog_attach(struct hif_opaque_softc *sc);
+static void pktlog_detach(struct ol_txrx_pdev_t *handle);
+static int pktlog_open(struct inode *i, struct file *f);
+static int pktlog_release(struct inode *i, struct file *f);
+static int pktlog_mmap(struct file *f, struct vm_area_struct *vma);
+static ssize_t pktlog_read(struct file *file, char *buf, size_t nbytes,
+			   loff_t *ppos);
+
+static struct file_operations pktlog_fops = {
+	open:  pktlog_open,
+	release:pktlog_release,
+	mmap : pktlog_mmap,
+	read : pktlog_read,
+};
+
+/*
+ * Linux implementation of helper functions
+ */
+static struct ol_pktlog_dev_t *cds_get_pl_handle(void)
+{
+	ol_txrx_pdev_handle pdev_txrx_handle;
+	pdev_txrx_handle = cds_get_context(QDF_MODULE_ID_TXRX);
+	if (!pdev_txrx_handle) {
+		QDF_ASSERT(0);
+		return NULL;
+	}
+	return pdev_txrx_handle->pl_dev;
+}
+
+static struct ol_pktlog_dev_t *ol_get_pl_handle(
+		ol_txrx_pdev_handle pdev_txrx_handle)
+{
+	if (!pdev_txrx_handle)
+		return NULL;
+	return pdev_txrx_handle->pl_dev;
+}
+
+void pktlog_disable_adapter_logging(struct hif_opaque_softc *scn)
+{
+	struct ol_pktlog_dev_t *pl_dev = cds_get_pl_handle();
+	if (pl_dev)
+		pl_dev->pl_info->log_state = 0;
+}
+
+int pktlog_alloc_buf(struct hif_opaque_softc *scn)
+{
+	uint32_t page_cnt;
+	unsigned long vaddr;
+	struct page *vpg;
+	struct ath_pktlog_info *pl_info;
+	ol_txrx_pdev_handle pdev_txrx_handle;
+	pdev_txrx_handle = cds_get_context(QDF_MODULE_ID_TXRX);
+
+	if (!pdev_txrx_handle || !pdev_txrx_handle->pl_dev) {
+		printk(PKTLOG_TAG
+		       "%s: Unable to allocate buffer "
+		       "scn or scn->pdev_txrx_handle->pl_dev is null\n",
+		       __func__);
+		return -EINVAL;
+	}
+
+	pl_info = pdev_txrx_handle->pl_dev->pl_info;
+
+	page_cnt = (sizeof(*(pl_info->buf)) + pl_info->buf_size) / PAGE_SIZE;
+
+	pl_info->buf = vmalloc((page_cnt + 2) * PAGE_SIZE);
+	if (pl_info->buf == NULL) {
+		printk(PKTLOG_TAG
+		       "%s: Unable to allocate buffer "
+		       "(%d pages)\n", __func__, page_cnt);
+		return -ENOMEM;
+	}
+
+	pl_info->buf = (struct ath_pktlog_buf *)
+		       (((unsigned long)(pl_info->buf) + PAGE_SIZE - 1)
+			& PAGE_MASK);
+
+	for (vaddr = (unsigned long)(pl_info->buf);
+	     vaddr < ((unsigned long)(pl_info->buf) + (page_cnt * PAGE_SIZE));
+	     vaddr += PAGE_SIZE) {
+		vpg = vmalloc_to_page((const void *)vaddr);
+		SetPageReserved(vpg);
+	}
+
+	return 0;
+}
+
+void pktlog_release_buf(ol_txrx_pdev_handle pdev_txrx_handle)
+{
+	unsigned long page_cnt;
+	unsigned long vaddr;
+	struct page *vpg;
+	struct ath_pktlog_info *pl_info;
+
+	if (!pdev_txrx_handle || !pdev_txrx_handle->pl_dev) {
+		printk(PKTLOG_TAG
+		       "%s: Unable to allocate buffer"
+		       "scn or scn->pdev_txrx_handle->pl_dev is null\n",
+		       __func__);
+		return;
+	}
+
+	pl_info = pdev_txrx_handle->pl_dev->pl_info;
+
+	page_cnt = ((sizeof(*(pl_info->buf)) + pl_info->buf_size) /
+		    PAGE_SIZE) + 1;
+
+	for (vaddr = (unsigned long)(pl_info->buf);
+	     vaddr < (unsigned long)(pl_info->buf) + (page_cnt * PAGE_SIZE);
+	     vaddr += PAGE_SIZE) {
+		vpg = vmalloc_to_page((const void *)vaddr);
+		ClearPageReserved(vpg);
+	}
+
+	vfree(pl_info->buf);
+	pl_info->buf = NULL;
+}
+
+static void pktlog_cleanup(struct ath_pktlog_info *pl_info)
+{
+	pl_info->log_state = 0;
+	PKTLOG_LOCK_DESTROY(pl_info);
+}
+
+/* sysctl procfs handler to enable pktlog */
+static int
+qdf_sysctl_decl(ath_sysctl_pktlog_enable, ctl, write, filp, buffer, lenp, ppos)
+{
+	int ret, enable;
+	ol_ath_generic_softc_handle scn;
+	struct ol_pktlog_dev_t *pl_dev;
+
+	scn = (ol_ath_generic_softc_handle) ctl->extra1;
+
+	if (!scn) {
+		printk("%s: Invalid scn context\n", __func__);
+		ASSERT(0);
+		return -EINVAL;
+	}
+
+	pl_dev = cds_get_pl_handle();
+
+	if (!pl_dev) {
+		printk("%s: Invalid pktlog context\n", __func__);
+		ASSERT(0);
+		return -ENODEV;
+	}
+
+	ctl->data = &enable;
+	ctl->maxlen = sizeof(enable);
+
+	if (write) {
+		ret = QDF_SYSCTL_PROC_DOINTVEC(ctl, write, filp, buffer,
+					       lenp, ppos);
+		if (ret == 0)
+			ret = pl_dev->pl_funcs->pktlog_enable(
+					(struct hif_opaque_softc *)scn, enable,
+					cds_is_packet_log_enabled(), 0, 1);
+		else
+			printk(PKTLOG_TAG "%s:proc_dointvec failed\n",
+			       __func__);
+	} else {
+		ret = QDF_SYSCTL_PROC_DOINTVEC(ctl, write, filp, buffer,
+					       lenp, ppos);
+		if (ret)
+			printk(PKTLOG_TAG "%s:proc_dointvec failed\n",
+			       __func__);
+	}
+
+	ctl->data = NULL;
+	ctl->maxlen = 0;
+
+	return ret;
+}
+
+static int get_pktlog_bufsize(struct ol_pktlog_dev_t *pl_dev)
+{
+	return pl_dev->pl_info->buf_size;
+}
+
+/* sysctl procfs handler to set/get pktlog size */
+static int
+qdf_sysctl_decl(ath_sysctl_pktlog_size, ctl, write, filp, buffer, lenp, ppos)
+{
+	int ret, size;
+	ol_ath_generic_softc_handle scn;
+	struct ol_pktlog_dev_t *pl_dev;
+
+	scn = (ol_ath_generic_softc_handle) ctl->extra1;
+
+	if (!scn) {
+		printk("%s: Invalid scn context\n", __func__);
+		ASSERT(0);
+		return -EINVAL;
+	}
+
+	pl_dev = cds_get_pl_handle();
+
+	if (!pl_dev) {
+		printk("%s: Invalid pktlog handle\n", __func__);
+		ASSERT(0);
+		return -ENODEV;
+	}
+
+	ctl->data = &size;
+	ctl->maxlen = sizeof(size);
+
+	if (write) {
+		ret = QDF_SYSCTL_PROC_DOINTVEC(ctl, write, filp, buffer,
+					       lenp, ppos);
+		if (ret == 0)
+			ret = pl_dev->pl_funcs->pktlog_setsize(
+					(struct hif_opaque_softc *)scn, size);
+	} else {
+		size = get_pktlog_bufsize(pl_dev);
+		ret = QDF_SYSCTL_PROC_DOINTVEC(ctl, write, filp, buffer,
+					       lenp, ppos);
+	}
+
+	ctl->data = NULL;
+	ctl->maxlen = 0;
+
+	return ret;
+}
+
+/* Register sysctl table */
+static int pktlog_sysctl_register(struct hif_opaque_softc *scn)
+{
+	struct ol_pktlog_dev_t *pl_dev = cds_get_pl_handle();
+	struct ath_pktlog_info_lnx *pl_info_lnx;
+	char *proc_name;
+
+	if (pl_dev) {
+		pl_info_lnx = PL_INFO_LNX(pl_dev->pl_info);
+		proc_name = pl_dev->name;
+	} else {
+		pl_info_lnx = PL_INFO_LNX(g_pktlog_info);
+		proc_name = PKTLOG_PROC_SYSTEM;
+	}
+
+	/*
+	 * Setup the sysctl table for creating the following sysctl entries:
+	 * /proc/sys/PKTLOG_PROC_DIR/<adapter>/enable for enabling/disabling
+	 * pktlog
+	 * /proc/sys/PKTLOG_PROC_DIR/<adapter>/size for changing the buffer size
+	 */
+	memset(pl_info_lnx->sysctls, 0, sizeof(pl_info_lnx->sysctls));
+	pl_info_lnx->sysctls[0].procname = PKTLOG_PROC_DIR;
+	pl_info_lnx->sysctls[0].mode = PKTLOG_PROCSYS_DIR_PERM;
+	pl_info_lnx->sysctls[0].child = &pl_info_lnx->sysctls[2];
+
+	/* [1] is NULL terminator */
+	pl_info_lnx->sysctls[2].procname = proc_name;
+	pl_info_lnx->sysctls[2].mode = PKTLOG_PROCSYS_DIR_PERM;
+	pl_info_lnx->sysctls[2].child = &pl_info_lnx->sysctls[4];
+
+	/* [3] is NULL terminator */
+	pl_info_lnx->sysctls[4].procname = "enable";
+	pl_info_lnx->sysctls[4].mode = PKTLOG_PROCSYS_PERM;
+	pl_info_lnx->sysctls[4].proc_handler = ath_sysctl_pktlog_enable;
+	pl_info_lnx->sysctls[4].extra1 = scn;
+
+	pl_info_lnx->sysctls[5].procname = "size";
+	pl_info_lnx->sysctls[5].mode = PKTLOG_PROCSYS_PERM;
+	pl_info_lnx->sysctls[5].proc_handler = ath_sysctl_pktlog_size;
+	pl_info_lnx->sysctls[5].extra1 = scn;
+
+	pl_info_lnx->sysctls[6].procname = "options";
+	pl_info_lnx->sysctls[6].mode = PKTLOG_PROCSYS_PERM;
+	pl_info_lnx->sysctls[6].proc_handler = proc_dointvec;
+	pl_info_lnx->sysctls[6].data = &pl_info_lnx->info.options;
+	pl_info_lnx->sysctls[6].maxlen = sizeof(pl_info_lnx->info.options);
+
+	pl_info_lnx->sysctls[7].procname = "sack_thr";
+	pl_info_lnx->sysctls[7].mode = PKTLOG_PROCSYS_PERM;
+	pl_info_lnx->sysctls[7].proc_handler = proc_dointvec;
+	pl_info_lnx->sysctls[7].data = &pl_info_lnx->info.sack_thr;
+	pl_info_lnx->sysctls[7].maxlen = sizeof(pl_info_lnx->info.sack_thr);
+
+	pl_info_lnx->sysctls[8].procname = "tail_length";
+	pl_info_lnx->sysctls[8].mode = PKTLOG_PROCSYS_PERM;
+	pl_info_lnx->sysctls[8].proc_handler = proc_dointvec;
+	pl_info_lnx->sysctls[8].data = &pl_info_lnx->info.tail_length;
+	pl_info_lnx->sysctls[8].maxlen = sizeof(pl_info_lnx->info.tail_length);
+
+	pl_info_lnx->sysctls[9].procname = "thruput_thresh";
+	pl_info_lnx->sysctls[9].mode = PKTLOG_PROCSYS_PERM;
+	pl_info_lnx->sysctls[9].proc_handler = proc_dointvec;
+	pl_info_lnx->sysctls[9].data = &pl_info_lnx->info.thruput_thresh;
+	pl_info_lnx->sysctls[9].maxlen =
+		sizeof(pl_info_lnx->info.thruput_thresh);
+
+	pl_info_lnx->sysctls[10].procname = "phyerr_thresh";
+	pl_info_lnx->sysctls[10].mode = PKTLOG_PROCSYS_PERM;
+	pl_info_lnx->sysctls[10].proc_handler = proc_dointvec;
+	pl_info_lnx->sysctls[10].data = &pl_info_lnx->info.phyerr_thresh;
+	pl_info_lnx->sysctls[10].maxlen =
+		sizeof(pl_info_lnx->info.phyerr_thresh);
+
+	pl_info_lnx->sysctls[11].procname = "per_thresh";
+	pl_info_lnx->sysctls[11].mode = PKTLOG_PROCSYS_PERM;
+	pl_info_lnx->sysctls[11].proc_handler = proc_dointvec;
+	pl_info_lnx->sysctls[11].data = &pl_info_lnx->info.per_thresh;
+	pl_info_lnx->sysctls[11].maxlen = sizeof(pl_info_lnx->info.per_thresh);
+
+	pl_info_lnx->sysctls[12].procname = "trigger_interval";
+	pl_info_lnx->sysctls[12].mode = PKTLOG_PROCSYS_PERM;
+	pl_info_lnx->sysctls[12].proc_handler = proc_dointvec;
+	pl_info_lnx->sysctls[12].data = &pl_info_lnx->info.trigger_interval;
+	pl_info_lnx->sysctls[12].maxlen =
+		sizeof(pl_info_lnx->info.trigger_interval);
+	/* [13] is NULL terminator */
+
+	/* and register everything */
+	/* register_sysctl_table changed from 2.6.21 onwards */
+	pl_info_lnx->sysctl_header =
+		register_sysctl_table(pl_info_lnx->sysctls);
+
+	if (!pl_info_lnx->sysctl_header) {
+		printk("%s: failed to register sysctls!\n", proc_name);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+/*
+ * Initialize logging for system or adapter
+ * Parameter scn should be NULL for system wide logging
+ */
+static int pktlog_attach(struct hif_opaque_softc *scn)
+{
+	struct ol_pktlog_dev_t *pl_dev;
+	struct ath_pktlog_info_lnx *pl_info_lnx;
+	char *proc_name;
+	struct proc_dir_entry *proc_entry;
+
+	pl_dev = cds_get_pl_handle();
+
+	if (pl_dev != NULL) {
+		pl_info_lnx = kmalloc(sizeof(*pl_info_lnx), GFP_KERNEL);
+		if (pl_info_lnx == NULL) {
+			printk(PKTLOG_TAG "%s:allocation failed for pl_info\n",
+			       __func__);
+			return -ENOMEM;
+		}
+		pl_dev->pl_info = &pl_info_lnx->info;
+		pl_dev->name = WLANDEV_BASENAME;
+		proc_name = pl_dev->name;
+		if (!pl_dev->pl_funcs)
+			pl_dev->pl_funcs = &ol_pl_funcs;
+
+		/*
+		 * Valid for both direct attach and offload architecture
+		 */
+		pl_dev->pl_funcs->pktlog_init(scn);
+	} else {
+		return -EINVAL;
+	}
+
+	/*
+	 * initialize log info
+	 * might be good to move to pktlog_init
+	 */
+	/* pl_dev->tgt_pktlog_alloced = false; */
+	pl_dev->vendor_cmd_send = false;
+	pl_info_lnx->proc_entry = NULL;
+	pl_info_lnx->sysctl_header = NULL;
+
+	proc_entry = proc_create_data(proc_name, PKTLOG_PROC_PERM,
+				      g_pktlog_pde, &pktlog_fops,
+				      &pl_info_lnx->info);
+
+	if (proc_entry == NULL) {
+		printk(PKTLOG_TAG "%s: create_proc_entry failed for %s\n",
+		       __func__, proc_name);
+		goto attach_fail1;
+	}
+
+	pl_info_lnx->proc_entry = proc_entry;
+
+	if (pktlog_sysctl_register(scn)) {
+		printk(PKTLOG_TAG "%s: sysctl register failed for %s\n",
+		       __func__, proc_name);
+		goto attach_fail2;
+	}
+	return 0;
+
+attach_fail2:
+	remove_proc_entry(proc_name, g_pktlog_pde);
+
+attach_fail1:
+	if (pl_dev)
+		kfree(pl_dev->pl_info);
+	return -EINVAL;
+}
+
+static void pktlog_sysctl_unregister(struct ol_pktlog_dev_t *pl_dev)
+{
+	struct ath_pktlog_info_lnx *pl_info_lnx;
+
+	if (!pl_dev) {
+		printk("%s: Invalid pktlog context\n", __func__);
+		ASSERT(0);
+		return;
+	}
+
+	pl_info_lnx = (pl_dev) ? PL_INFO_LNX(pl_dev->pl_info) :
+		      PL_INFO_LNX(g_pktlog_info);
+
+	if (pl_info_lnx->sysctl_header) {
+		unregister_sysctl_table(pl_info_lnx->sysctl_header);
+		pl_info_lnx->sysctl_header = NULL;
+	}
+}
+
+static void pktlog_detach(struct ol_txrx_pdev_t *handle)
+{
+	struct ol_txrx_pdev_t *txrx_pdev;
+	struct ol_pktlog_dev_t *pl_dev;
+	struct ath_pktlog_info *pl_info;
+
+	txrx_pdev = handle;
+	if (!txrx_pdev) {
+		printk("%s: Invalid txrx_pdev context\n", __func__);
+		ASSERT(0);
+		return;
+	}
+
+	pl_dev = txrx_pdev->pl_dev;
+	if (!pl_dev) {
+		printk("%s: Invalid pktlog context\n", __func__);
+		ASSERT(0);
+		return;
+	}
+
+	pl_info = pl_dev->pl_info;
+	remove_proc_entry(WLANDEV_BASENAME, g_pktlog_pde);
+	pktlog_sysctl_unregister(pl_dev);
+	pktlog_cleanup(pl_info);
+
+	if (pl_info->buf) {
+		pktlog_release_buf(txrx_pdev);
+		pl_dev->tgt_pktlog_alloced = false;
+	}
+
+	if (pl_dev) {
+		kfree(pl_info);
+		pl_dev->pl_info = NULL;
+	}
+}
+
+static int pktlog_open(struct inode *i, struct file *f)
+{
+	PKTLOG_MOD_INC_USE_COUNT;
+	return 0;
+}
+
+static int pktlog_release(struct inode *i, struct file *f)
+{
+	PKTLOG_MOD_DEC_USE_COUNT;
+	return 0;
+}
+
+#ifndef MIN
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+#endif
+
+/**
+ * pktlog_read_proc_entry() - This function is used to read data from the
+ * proc entry into the readers buffer
+ * @buf:     Readers buffer
+ * @nbytes:  Number of bytes to read
+ * @ppos:    Offset within the drivers buffer
+ * @pl_info: Packet log information pointer
+ * @read_complete: Boolean value indication whether read is complete
+ *
+ * This function is used to read data from the proc entry into the readers
+ * buffer. Its functionality is similar to 'pktlog_read' which does
+ * copy to user to the user space buffer
+ *
+ * Return: Number of bytes read from the buffer
+ *
+ */
+	ssize_t
+pktlog_read_proc_entry(char *buf, size_t nbytes, loff_t *ppos,
+		struct ath_pktlog_info *pl_info, bool *read_complete)
+{
+	size_t bufhdr_size;
+	size_t count = 0, ret_val = 0;
+	int rem_len;
+	int start_offset, end_offset;
+	int fold_offset, ppos_data, cur_rd_offset, cur_wr_offset;
+	struct ath_pktlog_buf *log_buf = pl_info->buf;
+	*read_complete = false;
+
+	if (log_buf == NULL) {
+		*read_complete = true;
+		return 0;
+	}
+
+	if (*ppos == 0 && pl_info->log_state) {
+		pl_info->saved_state = pl_info->log_state;
+		pl_info->log_state = 0;
+	}
+
+	bufhdr_size = sizeof(log_buf->bufhdr);
+
+	/* copy valid log entries from circular buffer into user space */
+	rem_len = nbytes;
+	count = 0;
+
+	if (*ppos < bufhdr_size) {
+		count = MIN((bufhdr_size - *ppos), rem_len);
+		qdf_mem_copy(buf, ((char *)&log_buf->bufhdr) + *ppos,
+				count);
+		rem_len -= count;
+		ret_val += count;
+	}
+
+	start_offset = log_buf->rd_offset;
+	cur_wr_offset = log_buf->wr_offset;
+
+	if ((rem_len == 0) || (start_offset < 0))
+		goto rd_done;
+
+	fold_offset = -1;
+	cur_rd_offset = start_offset;
+
+	/* Find the last offset and fold-offset if the buffer is folded */
+	do {
+		struct ath_pktlog_hdr *log_hdr;
+		int log_data_offset;
+
+		log_hdr = (struct ath_pktlog_hdr *) (log_buf->log_data +
+				cur_rd_offset);
+
+		log_data_offset = cur_rd_offset + sizeof(struct ath_pktlog_hdr);
+
+		if ((fold_offset == -1)
+				&& ((pl_info->buf_size - log_data_offset)
+					<= log_hdr->size))
+			fold_offset = log_data_offset - 1;
+
+		PKTLOG_MOV_RD_IDX(cur_rd_offset, log_buf, pl_info->buf_size);
+
+		if ((fold_offset == -1) && (cur_rd_offset == 0)
+				&& (cur_rd_offset != cur_wr_offset))
+			fold_offset = log_data_offset + log_hdr->size - 1;
+
+		end_offset = log_data_offset + log_hdr->size - 1;
+	} while (cur_rd_offset != cur_wr_offset);
+
+	ppos_data = *ppos + ret_val - bufhdr_size + start_offset;
+
+	if (fold_offset == -1) {
+		if (ppos_data > end_offset)
+			goto rd_done;
+
+		count = MIN(rem_len, (end_offset - ppos_data + 1));
+		qdf_mem_copy(buf + ret_val,
+				log_buf->log_data + ppos_data,
+				count);
+		ret_val += count;
+		rem_len -= count;
+	} else {
+		if (ppos_data <= fold_offset) {
+			count = MIN(rem_len, (fold_offset - ppos_data + 1));
+			qdf_mem_copy(buf + ret_val,
+					log_buf->log_data + ppos_data,
+					count);
+			ret_val += count;
+			rem_len -= count;
+		}
+
+		if (rem_len == 0)
+			goto rd_done;
+
+		ppos_data =
+			*ppos + ret_val - (bufhdr_size +
+					(fold_offset - start_offset + 1));
+
+		if (ppos_data <= end_offset) {
+			count = MIN(rem_len, (end_offset - ppos_data + 1));
+			qdf_mem_copy(buf + ret_val,
+					log_buf->log_data + ppos_data,
+					count);
+			ret_val += count;
+			rem_len -= count;
+		}
+	}
+
+rd_done:
+	if ((ret_val < nbytes) && pl_info->saved_state) {
+		pl_info->log_state = pl_info->saved_state;
+		pl_info->saved_state = 0;
+	}
+	*ppos += ret_val;
+
+	if (ret_val == 0) {
+		PKTLOG_LOCK(pl_info);
+		/* Write pointer might have been updated during the read.
+		 * So, if some data is written into, lets not reset the pointers
+		 * We can continue to read from the offset position
+		 */
+		if (cur_wr_offset != log_buf->wr_offset) {
+			*read_complete = false;
+		} else {
+			pl_info->buf->rd_offset = -1;
+			pl_info->buf->wr_offset = 0;
+			pl_info->buf->bytes_written = 0;
+			pl_info->buf->offset = PKTLOG_READ_OFFSET;
+			*read_complete = true;
+		}
+		PKTLOG_UNLOCK(pl_info);
+	}
+
+	return ret_val;
+}
+
+static ssize_t
+pktlog_read(struct file *file, char *buf, size_t nbytes, loff_t *ppos)
+{
+	size_t bufhdr_size;
+	size_t count = 0, ret_val = 0;
+	int rem_len;
+	int start_offset, end_offset;
+	int fold_offset, ppos_data, cur_rd_offset;
+	struct ath_pktlog_info *pl_info;
+	struct ath_pktlog_buf *log_buf;
+
+	pl_info = (struct ath_pktlog_info *)
+					PDE_DATA(file->f_path.dentry->d_inode);
+	if (!pl_info)
+		return 0;
+
+	log_buf = pl_info->buf;
+
+	if (log_buf == NULL)
+		return 0;
+
+	if (pl_info->log_state) {
+		/* Read is not allowed when write is going on
+		 * When issuing cat command, ensure to send
+		 * pktlog disable command first.
+		 */
+		return -EINVAL;
+	}
+
+	if (*ppos == 0 && pl_info->log_state) {
+		pl_info->saved_state = pl_info->log_state;
+		pl_info->log_state = 0;
+	}
+
+	bufhdr_size = sizeof(log_buf->bufhdr);
+
+	/* copy valid log entries from circular buffer into user space */
+	rem_len = nbytes;
+	count = 0;
+
+	if (*ppos < bufhdr_size) {
+		count = QDF_MIN((bufhdr_size - *ppos), rem_len);
+		if (copy_to_user(buf, ((char *)&log_buf->bufhdr) + *ppos,
+				 count))
+			return -EFAULT;
+		rem_len -= count;
+		ret_val += count;
+	}
+
+	start_offset = log_buf->rd_offset;
+
+	if ((rem_len == 0) || (start_offset < 0))
+		goto rd_done;
+
+	fold_offset = -1;
+	cur_rd_offset = start_offset;
+
+	/* Find the last offset and fold-offset if the buffer is folded */
+	do {
+		struct ath_pktlog_hdr *log_hdr;
+		int log_data_offset;
+
+		log_hdr = (struct ath_pktlog_hdr *)(log_buf->log_data +
+						    cur_rd_offset);
+
+		log_data_offset = cur_rd_offset + sizeof(struct ath_pktlog_hdr);
+
+		if ((fold_offset == -1)
+		    && ((pl_info->buf_size - log_data_offset)
+			<= log_hdr->size))
+			fold_offset = log_data_offset - 1;
+
+		PKTLOG_MOV_RD_IDX(cur_rd_offset, log_buf, pl_info->buf_size);
+
+		if ((fold_offset == -1) && (cur_rd_offset == 0)
+		    && (cur_rd_offset != log_buf->wr_offset))
+			fold_offset = log_data_offset + log_hdr->size - 1;
+
+		end_offset = log_data_offset + log_hdr->size - 1;
+	} while (cur_rd_offset != log_buf->wr_offset);
+
+	ppos_data = *ppos + ret_val - bufhdr_size + start_offset;
+
+	if (fold_offset == -1) {
+		if (ppos_data > end_offset)
+			goto rd_done;
+
+		count = QDF_MIN(rem_len, (end_offset - ppos_data + 1));
+		if (copy_to_user(buf + ret_val,
+				 log_buf->log_data + ppos_data, count))
+			return -EFAULT;
+		ret_val += count;
+		rem_len -= count;
+	} else {
+		if (ppos_data <= fold_offset) {
+			count = QDF_MIN(rem_len, (fold_offset - ppos_data + 1));
+			if (copy_to_user(buf + ret_val,
+					 log_buf->log_data + ppos_data, count))
+				return -EFAULT;
+			ret_val += count;
+			rem_len -= count;
+		}
+
+		if (rem_len == 0)
+			goto rd_done;
+
+		ppos_data =
+			*ppos + ret_val - (bufhdr_size +
+					   (fold_offset - start_offset + 1));
+
+		if (ppos_data <= end_offset) {
+			count = QDF_MIN(rem_len, (end_offset - ppos_data + 1));
+			if (copy_to_user(buf + ret_val,
+					 log_buf->log_data + ppos_data, count))
+				return -EFAULT;
+			ret_val += count;
+			rem_len -= count;
+		}
+	}
+
+rd_done:
+	if ((ret_val < nbytes) && pl_info->saved_state) {
+		pl_info->log_state = pl_info->saved_state;
+		pl_info->saved_state = 0;
+	}
+	*ppos += ret_val;
+
+	return ret_val;
+}
+
+#ifndef VMALLOC_VMADDR
+#define VMALLOC_VMADDR(x) ((unsigned long)(x))
+#endif
+
+/* vma operations for mapping vmalloced area to user space */
+static void pktlog_vopen(struct vm_area_struct *vma)
+{
+	PKTLOG_MOD_INC_USE_COUNT;
+}
+
+static void pktlog_vclose(struct vm_area_struct *vma)
+{
+	PKTLOG_MOD_DEC_USE_COUNT;
+}
+
+static int pktlog_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
+{
+	unsigned long address = (unsigned long)vmf->virtual_address;
+
+	if (address == 0UL)
+		return VM_FAULT_NOPAGE;
+
+	if (vmf->pgoff > vma->vm_end)
+		return VM_FAULT_SIGBUS;
+
+	get_page(virt_to_page((void *)address));
+	vmf->page = virt_to_page((void *)address);
+	return 0;
+}
+
+static struct vm_operations_struct pktlog_vmops = {
+	open:  pktlog_vopen,
+	close:pktlog_vclose,
+	fault:pktlog_fault,
+};
+
+static int pktlog_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	struct ath_pktlog_info *pl_info;
+
+	pl_info = (struct ath_pktlog_info *)
+					PDE_DATA(file->f_path.dentry->d_inode);
+
+	if (vma->vm_pgoff != 0) {
+		/* Entire buffer should be mapped */
+		return -EINVAL;
+	}
+
+	if (!pl_info->buf) {
+		printk(PKTLOG_TAG "%s: Log buffer unavailable\n", __func__);
+		return -ENOMEM;
+	}
+
+	vma->vm_flags |= VM_LOCKED;
+	vma->vm_ops = &pktlog_vmops;
+	pktlog_vopen(vma);
+	return 0;
+}
+
+int pktlogmod_init(void *context)
+{
+	int ret;
+
+	/* create the proc directory entry */
+	g_pktlog_pde = proc_mkdir(PKTLOG_PROC_DIR, NULL);
+
+	if (g_pktlog_pde == NULL) {
+		printk(PKTLOG_TAG "%s: proc_mkdir failed\n", __func__);
+		return -EPERM;
+	}
+
+	/* Attach packet log */
+	ret = pktlog_attach((struct hif_opaque_softc *)context);
+
+	if (ret)
+		goto attach_fail;
+
+	return ret;
+
+attach_fail:
+	remove_proc_entry(PKTLOG_PROC_DIR, NULL);
+	g_pktlog_pde = NULL;
+	return ret;
+}
+
+void pktlogmod_exit(struct ol_txrx_pdev_t *handle)
+{
+	struct ol_pktlog_dev_t *pl_dev;
+
+	pl_dev = ol_get_pl_handle(handle);
+
+	if (!pl_dev || g_pktlog_pde == NULL)
+		return;
+
+	pktlog_detach(handle);
+	/*
+	 *  pdev kill needs to be implemented
+	 */
+	remove_proc_entry(PKTLOG_PROC_DIR, NULL);
+}
+#endif

utils/pktlog/pktlog_ac.c

@@ -0,0 +1,715 @@
+/*
+ * Copyright (c) 2012-2017 The Linux Foundation. All rights reserved.
+ *
+ * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
+ *
+ *
+ * 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.
+ */
+
+/*
+ * This file was originally distributed by Qualcomm Atheros, Inc.
+ * under proprietary terms before Copyright ownership was assigned
+ * to the Linux Foundation.
+ */
+
+/*
+ *
+ * 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 REMOVE_PKT_LOG
+#include "qdf_mem.h"
+#include "athdefs.h"
+#include "pktlog_ac_i.h"
+#include "cds_api.h"
+#include "wma_types.h"
+#include "htc.h"
+
+wdi_event_subscribe PKTLOG_TX_SUBSCRIBER;
+wdi_event_subscribe PKTLOG_RX_SUBSCRIBER;
+wdi_event_subscribe PKTLOG_RX_REMOTE_SUBSCRIBER;
+wdi_event_subscribe PKTLOG_RCFIND_SUBSCRIBER;
+wdi_event_subscribe PKTLOG_RCUPDATE_SUBSCRIBER;
+wdi_event_subscribe PKTLOG_SW_EVENT_SUBSCRIBER;
+
+struct ol_pl_arch_dep_funcs ol_pl_funcs = {
+	.pktlog_init = pktlog_init,
+	.pktlog_enable = pktlog_enable,
+	.pktlog_setsize = pktlog_setsize,
+	.pktlog_disable = pktlog_disable,       /* valid for f/w disable */
+};
+
+struct ol_pktlog_dev_t ol_pl_dev = {
+	.pl_funcs = &ol_pl_funcs,
+};
+
+void ol_pl_sethandle(ol_pktlog_dev_handle *pl_handle,
+		     struct hif_opaque_softc *scn)
+{
+	ol_pl_dev.scn = (ol_ath_generic_softc_handle) scn;
+	*pl_handle = &ol_pl_dev;
+}
+
+static A_STATUS pktlog_wma_post_msg(WMI_PKTLOG_EVENT event_types,
+				    WMI_CMD_ID cmd_id, bool ini_triggered,
+				    uint8_t user_triggered)
+{
+	struct scheduler_msg msg = { 0 };
+	QDF_STATUS status;
+	struct ath_pktlog_wmi_params *param;
+
+	param = qdf_mem_malloc(sizeof(struct ath_pktlog_wmi_params));
+
+	if (!param)
+		return A_NO_MEMORY;
+
+	param->cmd_id = cmd_id;
+	param->pktlog_event = event_types;
+	param->ini_triggered = ini_triggered;
+	param->user_triggered = user_triggered;
+
+	msg.type = WMA_PKTLOG_ENABLE_REQ;
+	msg.bodyptr = param;
+	msg.bodyval = 0;
+
+	status = scheduler_post_msg(QDF_MODULE_ID_WMA, &msg);
+
+	if (status != QDF_STATUS_SUCCESS) {
+		qdf_mem_free(param);
+		return A_ERROR;
+	}
+
+	return A_OK;
+}
+
+static inline A_STATUS
+pktlog_enable_tgt(struct hif_opaque_softc *_scn, uint32_t log_state,
+		 bool ini_triggered, uint8_t user_triggered)
+{
+	uint32_t types = 0;
+
+	if (log_state & ATH_PKTLOG_TX)
+		types |= WMI_PKTLOG_EVENT_TX;
+
+	if (log_state & ATH_PKTLOG_RX)
+		types |= WMI_PKTLOG_EVENT_RX;
+
+	if (log_state & ATH_PKTLOG_RCFIND)
+		types |= WMI_PKTLOG_EVENT_RCF;
+
+	if (log_state & ATH_PKTLOG_RCUPDATE)
+		types |= WMI_PKTLOG_EVENT_RCU;
+
+	if (log_state & ATH_PKTLOG_SW_EVENT)
+		types |= WMI_PKTLOG_EVENT_SW;
+
+	return pktlog_wma_post_msg(types, WMI_PDEV_PKTLOG_ENABLE_CMDID,
+				   ini_triggered, user_triggered);
+}
+
+static inline A_STATUS
+wdi_pktlog_subscribe(struct ol_txrx_pdev_t *txrx_pdev, int32_t log_state)
+{
+	if (!txrx_pdev) {
+		printk("Invalid pdev in %s\n", __func__);
+		return A_ERROR;
+	}
+	if (log_state & ATH_PKTLOG_TX) {
+		if (wdi_event_sub(txrx_pdev,
+				  &PKTLOG_TX_SUBSCRIBER, WDI_EVENT_TX_STATUS)) {
+			return A_ERROR;
+		}
+	}
+	if (log_state & ATH_PKTLOG_RX) {
+		if (wdi_event_sub(txrx_pdev,
+				  &PKTLOG_RX_SUBSCRIBER, WDI_EVENT_RX_DESC)) {
+			return A_ERROR;
+		}
+		if (wdi_event_sub(txrx_pdev,
+				  &PKTLOG_RX_REMOTE_SUBSCRIBER,
+				  WDI_EVENT_RX_DESC_REMOTE)) {
+			return A_ERROR;
+		}
+	}
+	if (log_state & ATH_PKTLOG_RCFIND) {
+		if (wdi_event_sub(txrx_pdev,
+				  &PKTLOG_RCFIND_SUBSCRIBER,
+				  WDI_EVENT_RATE_FIND)) {
+			return A_ERROR;
+		}
+	}
+	if (log_state & ATH_PKTLOG_RCUPDATE) {
+		if (wdi_event_sub(txrx_pdev,
+				  &PKTLOG_RCUPDATE_SUBSCRIBER,
+				  WDI_EVENT_RATE_UPDATE)) {
+			return A_ERROR;
+		}
+	}
+	if (log_state & ATH_PKTLOG_SW_EVENT) {
+		if (wdi_event_sub(txrx_pdev,
+				  &PKTLOG_SW_EVENT_SUBSCRIBER,
+				  WDI_EVENT_SW_EVENT)) {
+			return A_ERROR;
+		}
+	}
+
+	return A_OK;
+}
+
+void pktlog_callback(void *pdev, enum WDI_EVENT event, void *log_data)
+{
+	switch (event) {
+	case WDI_EVENT_TX_STATUS:
+	{
+		/*
+		 * process TX message
+		 */
+		if (process_tx_info(pdev, log_data)) {
+			printk("Unable to process TX info\n");
+			return;
+		}
+		break;
+	}
+	case WDI_EVENT_RX_DESC:
+	{
+		/*
+		 * process RX message for local frames
+		 */
+		if (process_rx_info(pdev, log_data)) {
+			printk("Unable to process RX info\n");
+			return;
+		}
+		break;
+	}
+	case WDI_EVENT_RX_DESC_REMOTE:
+	{
+		/*
+		 * process RX message for remote frames
+		 */
+		if (process_rx_info_remote(pdev, log_data)) {
+			printk("Unable to process RX info\n");
+			return;
+		}
+		break;
+	}
+	case WDI_EVENT_RATE_FIND:
+	{
+		/*
+		 * process RATE_FIND message
+		 */
+		if (process_rate_find(pdev, log_data)) {
+			printk("Unable to process RC_FIND info\n");
+			return;
+		}
+		break;
+	}
+	case WDI_EVENT_RATE_UPDATE:
+	{
+		/*
+		 * process RATE_UPDATE message
+		 */
+		if (process_rate_update(pdev, log_data)) {
+			printk("Unable to process RC_UPDATE\n");
+			return;
+		}
+		break;
+	}
+	case WDI_EVENT_SW_EVENT:
+	{
+		/*
+		 * process SW EVENT message
+		 */
+		if (process_sw_event(pdev, log_data)) {
+			printk("Unable to process SW_EVENT\n");
+			return;
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}
+
+A_STATUS
+wdi_pktlog_unsubscribe(struct ol_txrx_pdev_t *txrx_pdev, uint32_t log_state)
+{
+	if (log_state & ATH_PKTLOG_TX) {
+		if (wdi_event_unsub(txrx_pdev,
+				    &PKTLOG_TX_SUBSCRIBER,
+				    WDI_EVENT_TX_STATUS)) {
+			return A_ERROR;
+		}
+	}
+	if (log_state & ATH_PKTLOG_RX) {
+		if (wdi_event_unsub(txrx_pdev,
+				    &PKTLOG_RX_SUBSCRIBER, WDI_EVENT_RX_DESC)) {
+			return A_ERROR;
+		}
+		if (wdi_event_unsub(txrx_pdev,
+				    &PKTLOG_RX_REMOTE_SUBSCRIBER,
+				    WDI_EVENT_RX_DESC_REMOTE)) {
+			return A_ERROR;
+		}
+	}
+	if (log_state & ATH_PKTLOG_RCFIND) {
+		if (wdi_event_unsub(txrx_pdev,
+				    &PKTLOG_RCFIND_SUBSCRIBER,
+				    WDI_EVENT_RATE_FIND)) {
+			return A_ERROR;
+		}
+	}
+	if (log_state & ATH_PKTLOG_RCUPDATE) {
+		if (wdi_event_unsub(txrx_pdev,
+				    &PKTLOG_RCUPDATE_SUBSCRIBER,
+				    WDI_EVENT_RATE_UPDATE)) {
+			return A_ERROR;
+		}
+	}
+	if (log_state & ATH_PKTLOG_RCUPDATE) {
+		if (wdi_event_unsub(txrx_pdev,
+				    &PKTLOG_SW_EVENT_SUBSCRIBER,
+				    WDI_EVENT_SW_EVENT)) {
+			return A_ERROR;
+		}
+	}
+	return A_OK;
+}
+
+int pktlog_disable(struct hif_opaque_softc *scn)
+{
+	struct ol_txrx_pdev_t *txrx_pdev =
+		cds_get_context(QDF_MODULE_ID_TXRX);
+	struct ol_pktlog_dev_t *pl_dev;
+	struct ath_pktlog_info *pl_info;
+
+	if (txrx_pdev == NULL ||
+			txrx_pdev->pl_dev == NULL ||
+			txrx_pdev->pl_dev->pl_info == NULL)
+		return -EFAULT;
+
+	pl_dev = txrx_pdev->pl_dev;
+	pl_info = pl_dev->pl_info;
+
+	if (pktlog_wma_post_msg(0, WMI_PDEV_PKTLOG_DISABLE_CMDID, 0, 0)) {
+		printk("Failed to disable pktlog in target\n");
+		return -EINVAL;
+	}
+
+	if (pl_dev->is_pktlog_cb_subscribed &&
+		wdi_pktlog_unsubscribe(txrx_pdev, pl_info->log_state)) {
+		printk("Cannot unsubscribe pktlog from the WDI\n");
+		return -EINVAL;
+	}
+	pl_dev->is_pktlog_cb_subscribed = false;
+	return 0;
+}
+
+void pktlog_init(struct hif_opaque_softc *scn)
+{
+	struct ath_pktlog_info *pl_info;
+	ol_txrx_pdev_handle pdev_txrx_handle;
+	pdev_txrx_handle = cds_get_context(QDF_MODULE_ID_TXRX);
+
+	if (pdev_txrx_handle == NULL ||
+			pdev_txrx_handle->pl_dev == NULL ||
+			pdev_txrx_handle->pl_dev->pl_info == NULL)
+		return;
+
+	pl_info = pdev_txrx_handle->pl_dev->pl_info;
+
+	OS_MEMZERO(pl_info, sizeof(*pl_info));
+	PKTLOG_LOCK_INIT(pl_info);
+
+	pl_info->buf_size = PKTLOG_DEFAULT_BUFSIZE;
+	pl_info->buf = NULL;
+	pl_info->log_state = 0;
+	pl_info->sack_thr = PKTLOG_DEFAULT_SACK_THR;
+	pl_info->tail_length = PKTLOG_DEFAULT_TAIL_LENGTH;
+	pl_info->thruput_thresh = PKTLOG_DEFAULT_THRUPUT_THRESH;
+	pl_info->per_thresh = PKTLOG_DEFAULT_PER_THRESH;
+	pl_info->phyerr_thresh = PKTLOG_DEFAULT_PHYERR_THRESH;
+	pl_info->trigger_interval = PKTLOG_DEFAULT_TRIGGER_INTERVAL;
+	pl_info->pktlen = 0;
+	pl_info->start_time_thruput = 0;
+	pl_info->start_time_per = 0;
+	pdev_txrx_handle->pl_dev->vendor_cmd_send = false;
+
+	PKTLOG_TX_SUBSCRIBER.callback = pktlog_callback;
+	PKTLOG_RX_SUBSCRIBER.callback = pktlog_callback;
+	PKTLOG_RX_REMOTE_SUBSCRIBER.callback = pktlog_callback;
+	PKTLOG_RCFIND_SUBSCRIBER.callback = pktlog_callback;
+	PKTLOG_RCUPDATE_SUBSCRIBER.callback = pktlog_callback;
+	PKTLOG_SW_EVENT_SUBSCRIBER.callback = pktlog_callback;
+}
+
+int pktlog_enable(struct hif_opaque_softc *scn, int32_t log_state,
+		 bool ini_triggered, uint8_t user_triggered,
+		 uint32_t is_iwpriv_command)
+{
+	struct ol_pktlog_dev_t *pl_dev;
+	struct ath_pktlog_info *pl_info;
+	struct ol_txrx_pdev_t *txrx_pdev;
+	int error;
+
+	if (!scn) {
+		printk("%s: Invalid scn context\n", __func__);
+		ASSERT(0);
+		return -EINVAL;
+	}
+
+	txrx_pdev = cds_get_context(QDF_MODULE_ID_TXRX);
+	if (!txrx_pdev) {
+		printk("%s: Invalid txrx_pdev context\n", __func__);
+		ASSERT(0);
+		return -EINVAL;
+	}
+
+	pl_dev = txrx_pdev->pl_dev;
+	if (!pl_dev) {
+		printk("%s: Invalid pktlog context\n", __func__);
+		ASSERT(0);
+		return -EINVAL;
+	}
+
+	pl_info = pl_dev->pl_info;
+
+	if (!pl_info)
+		return 0;
+
+	/* is_iwpriv_command : 0 indicates its a vendor command
+	 * log_state: 0 indicates pktlog disable command
+	 * vendor_cmd_send flag; false means no vendor pktlog enable
+	 * command was sent previously
+	 */
+	if (is_iwpriv_command == 0 && log_state == 0 &&
+	    pl_dev->vendor_cmd_send == false)
+		return 0;
+
+	if (!pl_dev->tgt_pktlog_alloced) {
+		if (pl_info->buf == NULL) {
+			error = pktlog_alloc_buf(scn);
+
+			if (error != 0)
+				return error;
+
+			if (!pl_info->buf) {
+				printk("%s: pktlog buf alloc failed\n",
+				       __func__);
+				ASSERT(0);
+				return -ENOMEM;
+			}
+
+		}
+
+		pl_info->buf->bufhdr.version = CUR_PKTLOG_VER;
+		pl_info->buf->bufhdr.magic_num = PKTLOG_MAGIC_NUM;
+		pl_info->buf->wr_offset = 0;
+		pl_info->buf->rd_offset = -1;
+		/* These below variables are used by per packet stats*/
+		pl_info->buf->bytes_written = 0;
+		pl_info->buf->msg_index = 1;
+		pl_info->buf->offset = PKTLOG_READ_OFFSET;
+
+		pl_info->start_time_thruput = os_get_timestamp();
+		pl_info->start_time_per = pl_info->start_time_thruput;
+
+		pl_dev->tgt_pktlog_alloced = true;
+	}
+
+	if (log_state != 0) {
+		/* WDI subscribe */
+		if ((!pl_dev->is_pktlog_cb_subscribed) &&
+			wdi_pktlog_subscribe(txrx_pdev, log_state)) {
+			printk("Unable to subscribe to the WDI %s\n", __func__);
+			return -EINVAL;
+		}
+		pl_dev->is_pktlog_cb_subscribed = true;
+		/* WMI command to enable pktlog on the firmware */
+		if (pktlog_enable_tgt(scn, log_state, ini_triggered,
+				user_triggered)) {
+			printk("Device cannot be enabled, %s\n", __func__);
+			return -EINVAL;
+		}
+
+		if (is_iwpriv_command == 0)
+			pl_dev->vendor_cmd_send = true;
+	} else {
+		pl_dev->pl_funcs->pktlog_disable(scn);
+		if (is_iwpriv_command == 0)
+			pl_dev->vendor_cmd_send = false;
+	}
+
+	pl_info->log_state = log_state;
+	return 0;
+}
+
+int pktlog_setsize(struct hif_opaque_softc *scn, int32_t size)
+{
+	ol_txrx_pdev_handle pdev_txrx_handle =
+		cds_get_context(QDF_MODULE_ID_TXRX);
+	struct ol_pktlog_dev_t *pl_dev;
+	struct ath_pktlog_info *pl_info;
+
+	if (pdev_txrx_handle == NULL ||
+			pdev_txrx_handle->pl_dev == NULL ||
+			pdev_txrx_handle->pl_dev->pl_info == NULL)
+		return -EFAULT;
+
+	pl_dev = pdev_txrx_handle->pl_dev;
+	pl_info = pl_dev->pl_info;
+
+	if (size < 0)
+		return -EINVAL;
+
+	if (size == pl_info->buf_size) {
+		qdf_print("%s: Pktlog Buff Size is already of same size.",
+			  __func__);
+		return 0;
+	}
+
+	if (pl_info->log_state) {
+		qdf_print("%s: Logging should be disabled before changing"
+			  "buffer size.", __func__);
+		return -EINVAL;
+	}
+
+	if (pl_info->buf != NULL) {
+		if (pl_dev->is_pktlog_cb_subscribed &&
+			wdi_pktlog_unsubscribe(pdev_txrx_handle,
+					 pl_info->log_state)) {
+			printk("Cannot unsubscribe pktlog from the WDI\n");
+			return -EFAULT;
+		}
+		pktlog_release_buf(pdev_txrx_handle);
+		pl_dev->is_pktlog_cb_subscribed = false;
+		pl_dev->tgt_pktlog_alloced = false;
+	}
+
+	if (size != 0) {
+		qdf_print("%s: New Pktlog Buff Size is %d\n", __func__, size);
+		pl_info->buf_size = size;
+	}
+
+	return 0;
+}
+
+/**
+ * pktlog_process_fw_msg() - process packetlog message
+ * @buff: buffer
+ *
+ * Return: None
+ */
+void pktlog_process_fw_msg(uint32_t *buff)
+{
+	uint32_t *pl_hdr;
+	uint32_t log_type;
+	struct ol_txrx_pdev_t *txrx_pdev = cds_get_context(QDF_MODULE_ID_TXRX);
+
+	if (!txrx_pdev) {
+		qdf_print("%s: txrx_pdev is NULL", __func__);
+		return;
+	}
+
+	pl_hdr = buff;
+	log_type =
+		(*(pl_hdr + 1) & ATH_PKTLOG_HDR_LOG_TYPE_MASK) >>
+		ATH_PKTLOG_HDR_LOG_TYPE_SHIFT;
+	if ((log_type == PKTLOG_TYPE_TX_CTRL)
+		|| (log_type == PKTLOG_TYPE_TX_STAT)
+		|| (log_type == PKTLOG_TYPE_TX_MSDU_ID)
+		|| (log_type == PKTLOG_TYPE_TX_FRM_HDR)
+		|| (log_type == PKTLOG_TYPE_TX_VIRT_ADDR))
+		wdi_event_handler(WDI_EVENT_TX_STATUS,
+				  txrx_pdev, pl_hdr);
+	else if (log_type == PKTLOG_TYPE_RC_FIND)
+		wdi_event_handler(WDI_EVENT_RATE_FIND,
+				  txrx_pdev, pl_hdr);
+	else if (log_type == PKTLOG_TYPE_RC_UPDATE)
+		wdi_event_handler(WDI_EVENT_RATE_UPDATE,
+				  txrx_pdev, pl_hdr);
+	else if (log_type == PKTLOG_TYPE_RX_STAT)
+		wdi_event_handler(WDI_EVENT_RX_DESC,
+				  txrx_pdev, pl_hdr);
+	else if (log_type == PKTLOG_TYPE_SW_EVENT)
+		wdi_event_handler(WDI_EVENT_SW_EVENT,
+				  txrx_pdev, pl_hdr);
+
+}
+
+#if defined(QCA_WIFI_3_0_ADRASTEA)
+/**
+ * pktlog_t2h_msg_handler() - Target to host message handler
+ * @context: pdev context
+ * @pkt: HTC packet
+ *
+ * Return: None
+ */
+static void pktlog_t2h_msg_handler(void *context, HTC_PACKET *pkt)
+{
+	struct ol_pktlog_dev_t *pdev = (struct ol_pktlog_dev_t *)context;
+	qdf_nbuf_t pktlog_t2h_msg = (qdf_nbuf_t) pkt->pPktContext;
+	uint32_t *msg_word;
+
+	/* check for successful message reception */
+	if (pkt->Status != A_OK) {
+		if (pkt->Status != A_ECANCELED)
+			pdev->htc_err_cnt++;
+		qdf_nbuf_free(pktlog_t2h_msg);
+		return;
+	}
+
+	/* confirm alignment */
+	qdf_assert((((unsigned long)qdf_nbuf_data(pktlog_t2h_msg)) & 0x3) == 0);
+
+	msg_word = (uint32_t *) qdf_nbuf_data(pktlog_t2h_msg);
+	pktlog_process_fw_msg(msg_word);
+
+	qdf_nbuf_free(pktlog_t2h_msg);
+}
+
+/**
+ * pktlog_tx_resume_handler() - resume callback
+ * @context: pdev context
+ *
+ * Return: None
+ */
+static void pktlog_tx_resume_handler(void *context)
+{
+	qdf_print("%s: Not expected", __func__);
+	qdf_assert(0);
+}
+
+/**
+ * pktlog_h2t_send_complete() - send complete indication
+ * @context: pdev context
+ * @htc_pkt: HTC packet
+ *
+ * Return: None
+ */
+static void pktlog_h2t_send_complete(void *context, HTC_PACKET *htc_pkt)
+{
+	qdf_print("%s: Not expected", __func__);
+	qdf_assert(0);
+}
+
+/**
+ * pktlog_h2t_full() - queue full indication
+ * @context: pdev context
+ * @pkt: HTC packet
+ *
+ * Return: HTC action
+ */
+static HTC_SEND_FULL_ACTION pktlog_h2t_full(void *context, HTC_PACKET *pkt)
+{
+	return HTC_SEND_FULL_KEEP;
+}
+
+/**
+ * pktlog_htc_connect_service() - create new endpoint for packetlog
+ * @pdev - pktlog pdev
+ *
+ * Return: 0 for success/failure
+ */
+static int pktlog_htc_connect_service(struct ol_pktlog_dev_t *pdev)
+{
+	HTC_SERVICE_CONNECT_REQ connect;
+	HTC_SERVICE_CONNECT_RESP response;
+	A_STATUS status;
+
+	qdf_mem_set(&connect, sizeof(connect), 0);
+	qdf_mem_set(&response, sizeof(response), 0);
+
+	connect.pMetaData = NULL;
+	connect.MetaDataLength = 0;
+	connect.EpCallbacks.pContext = pdev;
+	connect.EpCallbacks.EpTxComplete = pktlog_h2t_send_complete;
+	connect.EpCallbacks.EpTxCompleteMultiple = NULL;
+	connect.EpCallbacks.EpRecv = pktlog_t2h_msg_handler;
+	connect.EpCallbacks.ep_resume_tx_queue = pktlog_tx_resume_handler;
+
+	/* rx buffers currently are provided by HIF, not by EpRecvRefill */
+	connect.EpCallbacks.EpRecvRefill = NULL;
+	connect.EpCallbacks.RecvRefillWaterMark = 1;
+	/* N/A, fill is done by HIF */
+
+	connect.EpCallbacks.EpSendFull = pktlog_h2t_full;
+	/*
+	 * Specify how deep to let a queue get before htc_send_pkt will
+	 * call the EpSendFull function due to excessive send queue depth.
+	 */
+	connect.MaxSendQueueDepth = PKTLOG_MAX_SEND_QUEUE_DEPTH;
+
+	/* disable flow control for HTT data message service */
+	connect.ConnectionFlags |= HTC_CONNECT_FLAGS_DISABLE_CREDIT_FLOW_CTRL;
+
+	/* connect to control service */
+	connect.service_id = PACKET_LOG_SVC;
+
+	status = htc_connect_service(pdev->htc_pdev, &connect, &response);
+
+	if (status != A_OK) {
+		pdev->mt_pktlog_enabled = false;
+		return -EIO;       /* failure */
+	}
+
+	pdev->htc_endpoint = response.Endpoint;
+	pdev->mt_pktlog_enabled = true;
+
+	return 0;               /* success */
+}
+
+/**
+ * pktlog_htc_attach() - attach pktlog HTC service
+ *
+ * Return: 0 for success/failure
+ */
+int pktlog_htc_attach(void)
+{
+	struct ol_txrx_pdev_t *txrx_pdev = cds_get_context(QDF_MODULE_ID_TXRX);
+	struct ol_pktlog_dev_t *pdev = NULL;
+	void *htc_pdev = cds_get_context(QDF_MODULE_ID_HTC);
+
+	if ((!txrx_pdev) || (!txrx_pdev->pl_dev) || (!htc_pdev))
+		return -EINVAL;
+
+	pdev = txrx_pdev->pl_dev;
+	pdev->htc_pdev = htc_pdev;
+	return pktlog_htc_connect_service(pdev);
+}
+#else
+int pktlog_htc_attach(void)
+{
+	struct ol_txrx_pdev_t *txrx_pdev = cds_get_context(QDF_MODULE_ID_TXRX);
+	struct ol_pktlog_dev_t *pdev = NULL;
+
+	if (!txrx_pdev)
+		return -EINVAL;
+	pdev = txrx_pdev->pl_dev;
+	pdev->mt_pktlog_enabled = false;
+	return 0;
+}
+#endif
+#endif /* REMOVE_PKT_LOG */

utils/pktlog/pktlog_internal.c

@@ -0,0 +1,871 @@
+/*
+ * Copyright (c) 2013-2017 The Linux Foundation. All rights reserved.
+ *
+ * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
+ *
+ *
+ * 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.
+ */
+
+/*
+ * This file was originally distributed by Qualcomm Atheros, Inc.
+ * under proprietary terms before Copyright ownership was assigned
+ * to the Linux Foundation.
+ */
+
+/*
+ *
+ * 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 REMOVE_PKT_LOG
+#include "ol_txrx_types.h"
+#include "ol_htt_tx_api.h"
+#include "ol_tx_desc.h"
+#include "qdf_mem.h"
+#include "htt.h"
+#include "htt_internal.h"
+#include "pktlog_ac_i.h"
+#include "wma_api.h"
+#include "wlan_logging_sock_svc.h"
+
+#define TX_DESC_ID_LOW_MASK     0xffff
+#define TX_DESC_ID_LOW_SHIFT    0
+#define TX_DESC_ID_HIGH_MASK    0xffff0000
+#define TX_DESC_ID_HIGH_SHIFT   16
+
+void pktlog_getbuf_intsafe(struct ath_pktlog_arg *plarg)
+{
+	struct ath_pktlog_buf *log_buf;
+	int32_t buf_size;
+	struct ath_pktlog_hdr *log_hdr;
+	int32_t cur_wr_offset;
+	char *log_ptr;
+	struct ath_pktlog_info *pl_info;
+	uint16_t log_type;
+	size_t log_size;
+	uint32_t flags;
+#ifdef HELIUMPLUS
+	uint8_t mac_id;
+#endif
+
+	if (!plarg) {
+		printk("Invalid parg in %s\n", __func__);
+		return;
+	}
+
+	pl_info = plarg->pl_info;
+#ifdef HELIUMPLUS
+	mac_id = plarg->macId;
+	log_type = plarg->log_type;
+#else
+	log_type = plarg->log_type;
+#endif
+	log_size = plarg->log_size;
+	log_buf = pl_info->buf;
+	flags = plarg->flags;
+
+	if (!log_buf) {
+		printk("Invalid log_buf in %s\n", __func__);
+		return;
+	}
+	buf_size = pl_info->buf_size;
+	cur_wr_offset = log_buf->wr_offset;
+	/* Move read offset to the next entry if there is a buffer overlap */
+	if (log_buf->rd_offset >= 0) {
+		if ((cur_wr_offset <= log_buf->rd_offset)
+		    && (cur_wr_offset + sizeof(struct ath_pktlog_hdr)) >
+		    log_buf->rd_offset) {
+			PKTLOG_MOV_RD_IDX(log_buf->rd_offset, log_buf,
+					  buf_size);
+		}
+	} else {
+		log_buf->rd_offset = cur_wr_offset;
+	}
+
+	log_hdr = (struct ath_pktlog_hdr *)(log_buf->log_data + cur_wr_offset);
+
+	log_hdr->flags = flags;
+#ifdef HELIUMPLUS
+	log_hdr->macId = mac_id;
+	log_hdr->log_type = log_type;
+#else
+	log_hdr->log_type = log_type;
+#endif
+	log_hdr->size = (uint16_t) log_size;
+	log_hdr->missed_cnt = plarg->missed_cnt;
+	log_hdr->timestamp = plarg->timestamp;
+#ifdef HELIUMPLUS
+	log_hdr->type_specific_data = plarg->type_specific_data;
+#endif
+	cur_wr_offset += sizeof(*log_hdr);
+
+	if ((buf_size - cur_wr_offset) < log_size) {
+		while ((cur_wr_offset <= log_buf->rd_offset)
+		       && (log_buf->rd_offset < buf_size)) {
+			PKTLOG_MOV_RD_IDX(log_buf->rd_offset, log_buf,
+					  buf_size);
+		}
+		cur_wr_offset = 0;
+	}
+
+	while ((cur_wr_offset <= log_buf->rd_offset)
+	       && (cur_wr_offset + log_size) > log_buf->rd_offset) {
+		PKTLOG_MOV_RD_IDX(log_buf->rd_offset, log_buf, buf_size);
+	}
+
+	log_ptr = &(log_buf->log_data[cur_wr_offset]);
+	cur_wr_offset += log_hdr->size;
+
+	log_buf->wr_offset = ((buf_size - cur_wr_offset) >=
+			      sizeof(struct ath_pktlog_hdr)) ? cur_wr_offset :
+			     0;
+
+	plarg->buf = log_ptr;
+}
+
+char *pktlog_getbuf(struct ol_pktlog_dev_t *pl_dev,
+		    struct ath_pktlog_info *pl_info,
+		    size_t log_size, struct ath_pktlog_hdr *pl_hdr)
+{
+	struct ath_pktlog_arg plarg = { 0, };
+	uint8_t flags = 0;
+
+	plarg.pl_info = pl_info;
+#ifdef HELIUMPLUS
+	plarg.macId = pl_hdr->macId;
+	plarg.log_type = pl_hdr->log_type;
+#else
+	plarg.log_type = pl_hdr->log_type;
+#endif
+	plarg.log_size = log_size;
+	plarg.flags = pl_hdr->flags;
+	plarg.missed_cnt = pl_hdr->missed_cnt;
+	plarg.timestamp = pl_hdr->timestamp;
+#ifdef HELIUMPLUS
+	plarg.type_specific_data = pl_hdr->type_specific_data;
+#endif
+	if (flags & PHFLAGS_INTERRUPT_CONTEXT) {
+		/*
+		 * We are already in interupt context, no need to make it
+		 * intsafe. call the function directly.
+		 */
+		pktlog_getbuf_intsafe(&plarg);
+	} else {
+		PKTLOG_LOCK(pl_info);
+		pktlog_getbuf_intsafe(&plarg);
+		PKTLOG_UNLOCK(pl_info);
+	}
+
+	return plarg.buf;
+}
+
+static struct txctl_frm_hdr frm_hdr;
+
+#ifndef HELIUMPLUS
+static void process_ieee_hdr(void *data)
+{
+	uint8_t dir;
+	struct ieee80211_frame *wh = (struct ieee80211_frame *)(data);
+
+	frm_hdr.framectrl = *(uint16_t *) (wh->i_fc);
+	frm_hdr.seqctrl = *(uint16_t *) (wh->i_seq);
+	dir = (wh->i_fc[1] & IEEE80211_FC1_DIR_MASK);
+
+	if (dir == IEEE80211_FC1_DIR_TODS) {
+		frm_hdr.bssid_tail =
+			(wh->i_addr1[IEEE80211_ADDR_LEN - 2] << 8) | (wh->
+								      i_addr1
+								      [IEEE80211_ADDR_LEN
+								       - 1]);
+		frm_hdr.sa_tail =
+			(wh->i_addr2[IEEE80211_ADDR_LEN - 2] << 8) | (wh->
+								      i_addr2
+								      [IEEE80211_ADDR_LEN
+								       - 1]);
+		frm_hdr.da_tail =
+			(wh->i_addr3[IEEE80211_ADDR_LEN - 2] << 8) | (wh->
+								      i_addr3
+								      [IEEE80211_ADDR_LEN
+								       - 1]);
+	} else if (dir == IEEE80211_FC1_DIR_FROMDS) {
+		frm_hdr.bssid_tail =
+			(wh->i_addr2[IEEE80211_ADDR_LEN - 2] << 8) | (wh->
+								      i_addr2
+								      [IEEE80211_ADDR_LEN
+								       - 1]);
+		frm_hdr.sa_tail =
+			(wh->i_addr3[IEEE80211_ADDR_LEN - 2] << 8) | (wh->
+								      i_addr3
+								      [IEEE80211_ADDR_LEN
+								       - 1]);
+		frm_hdr.da_tail =
+			(wh->i_addr1[IEEE80211_ADDR_LEN - 2] << 8) | (wh->
+								      i_addr1
+								      [IEEE80211_ADDR_LEN
+								       - 1]);
+	} else {
+		frm_hdr.bssid_tail =
+			(wh->i_addr3[IEEE80211_ADDR_LEN - 2] << 8) | (wh->
+								      i_addr3
+								      [IEEE80211_ADDR_LEN
+								       - 1]);
+		frm_hdr.sa_tail =
+			(wh->i_addr2[IEEE80211_ADDR_LEN - 2] << 8) | (wh->
+								      i_addr2
+								      [IEEE80211_ADDR_LEN
+								       - 1]);
+		frm_hdr.da_tail =
+			(wh->i_addr1[IEEE80211_ADDR_LEN - 2] << 8) | (wh->
+								      i_addr1
+								      [IEEE80211_ADDR_LEN
+								       - 1]);
+	}
+}
+
+/**
+ * fill_ieee80211_hdr_data() - fill ieee802.11 data header
+ * @txrx_pdev: txrx pdev
+ * @pl_msdu_info: msdu info
+ * @data: data received from event
+ *
+ * Return: none
+ */
+static void
+fill_ieee80211_hdr_data(struct ol_txrx_pdev_t *txrx_pdev,
+	struct ath_pktlog_msdu_info *pl_msdu_info, void *data)
+{
+	uint32_t i;
+	uint32_t *htt_tx_desc;
+	struct ol_tx_desc_t *tx_desc;
+	uint8_t msdu_id_offset = MSDU_ID_INFO_ID_OFFSET;
+	uint16_t tx_desc_id;
+	uint32_t *msdu_id_info = (uint32_t *)
+				 ((void *)data + sizeof(struct ath_pktlog_hdr));
+	uint32_t *msdu_id = (uint32_t *) ((char *)msdu_id_info +
+					  msdu_id_offset);
+	uint8_t *addr, *vap_addr;
+	uint8_t vdev_id;
+	qdf_nbuf_t netbuf;
+	uint32_t len;
+
+
+	pl_msdu_info->num_msdu = *msdu_id_info;
+	pl_msdu_info->priv_size = sizeof(uint32_t) *
+				 pl_msdu_info->num_msdu + sizeof(uint32_t);
+
+	for (i = 0; i < pl_msdu_info->num_msdu; i++) {
+		/*
+		 * Handle big endianness
+		 * Increment msdu_id once after retrieving
+		 * lower 16 bits and uppper 16 bits
+		 */
+		if (!(i % 2)) {
+			tx_desc_id = ((*msdu_id & TX_DESC_ID_LOW_MASK)
+				      >> TX_DESC_ID_LOW_SHIFT);
+		} else {
+			tx_desc_id = ((*msdu_id & TX_DESC_ID_HIGH_MASK)
+				      >> TX_DESC_ID_HIGH_SHIFT);
+			msdu_id += 1;
+		}
+		tx_desc = ol_tx_desc_find(txrx_pdev, tx_desc_id);
+		qdf_assert(tx_desc);
+		netbuf = tx_desc->netbuf;
+		htt_tx_desc = (uint32_t *) tx_desc->htt_tx_desc;
+		qdf_assert(htt_tx_desc);
+
+		qdf_nbuf_peek_header(netbuf, &addr, &len);
+
+		if (len < (2 * IEEE80211_ADDR_LEN)) {
+			qdf_print("TX frame does not have a valid address\n");
+			return;
+		}
+		/* Adding header information for the TX data frames */
+		vdev_id = (uint8_t) (*(htt_tx_desc +
+				       HTT_TX_VDEV_ID_WORD) >>
+				     HTT_TX_VDEV_ID_SHIFT) &
+			  HTT_TX_VDEV_ID_MASK;
+
+		vap_addr = wma_get_vdev_address_by_vdev_id(vdev_id);
+
+		frm_hdr.da_tail = (addr[IEEE80211_ADDR_LEN - 2] << 8) |
+				  (addr[IEEE80211_ADDR_LEN - 1]);
+		frm_hdr.sa_tail =
+			(addr[2 * IEEE80211_ADDR_LEN - 2] << 8) |
+			(addr[2 * IEEE80211_ADDR_LEN - 1]);
+		if (vap_addr) {
+			frm_hdr.bssid_tail =
+				(vap_addr[IEEE80211_ADDR_LEN - 2] << 8) |
+				(vap_addr[IEEE80211_ADDR_LEN - 1]);
+		} else {
+			frm_hdr.bssid_tail = 0x0000;
+		}
+		pl_msdu_info->priv.msdu_len[i] = *(htt_tx_desc +
+						  HTT_TX_MSDU_LEN_DWORD)
+						& HTT_TX_MSDU_LEN_MASK;
+		/*
+		 * Add more information per MSDU
+		 * e.g., protocol information
+		 */
+	}
+
+}
+#endif
+
+#ifdef HELIUMPLUS
+A_STATUS process_tx_info(struct ol_txrx_pdev_t *txrx_pdev, void *data)
+{
+	/*
+	 * Must include to process different types
+	 * TX_CTL, TX_STATUS, TX_MSDU_ID, TX_FRM_HDR
+	 */
+	struct ol_pktlog_dev_t *pl_dev;
+	struct ath_pktlog_hdr pl_hdr;
+	struct ath_pktlog_info *pl_info;
+	uint32_t *pl_tgt_hdr;
+
+	if (!txrx_pdev) {
+		printk("Invalid pdev in %s\n", __func__);
+		return A_ERROR;
+	}
+	qdf_assert(txrx_pdev->pl_dev);
+	qdf_assert(data);
+	pl_dev = txrx_pdev->pl_dev;
+
+	pl_tgt_hdr = (uint32_t *) data;
+	/*
+	 * Makes the short words (16 bits) portable b/w little endian
+	 * and big endian
+	 */
+	pl_hdr.flags = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_FLAGS_OFFSET) &
+			ATH_PKTLOG_HDR_FLAGS_MASK) >>
+		       ATH_PKTLOG_HDR_FLAGS_SHIFT;
+	pl_hdr.flags |= PKTLOG_HDR_SIZE_16;
+	pl_hdr.missed_cnt = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_MISSED_CNT_OFFSET) &
+			     ATH_PKTLOG_HDR_MISSED_CNT_MASK) >>
+			    ATH_PKTLOG_HDR_MISSED_CNT_SHIFT;
+	pl_hdr.log_type = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_LOG_TYPE_OFFSET) &
+		   ATH_PKTLOG_HDR_LOG_TYPE_MASK) >>
+		  ATH_PKTLOG_HDR_LOG_TYPE_SHIFT;
+	pl_hdr.macId = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_MAC_ID_OFFSET) &
+		   ATH_PKTLOG_HDR_MAC_ID_MASK) >>
+		  ATH_PKTLOG_HDR_MAC_ID_SHIFT;
+	pl_hdr.size = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_SIZE_OFFSET) &
+		       ATH_PKTLOG_HDR_SIZE_MASK) >> ATH_PKTLOG_HDR_SIZE_SHIFT;
+	pl_hdr.timestamp = *(pl_tgt_hdr + ATH_PKTLOG_HDR_TIMESTAMP_OFFSET);
+	pl_hdr.type_specific_data =
+		*(pl_tgt_hdr + ATH_PKTLOG_HDR_TYPE_SPECIFIC_DATA_OFFSET);
+	pl_info = pl_dev->pl_info;
+
+	if (pl_hdr.log_type == PKTLOG_TYPE_TX_CTRL) {
+		size_t log_size = sizeof(frm_hdr) + pl_hdr.size;
+		void *txdesc_hdr_ctl = (void *)
+		pktlog_getbuf(pl_dev, pl_info, log_size, &pl_hdr);
+		qdf_assert(txdesc_hdr_ctl);
+		qdf_assert(pl_hdr.size < (370 * sizeof(u_int32_t)));
+
+		qdf_mem_copy(txdesc_hdr_ctl, &frm_hdr, sizeof(frm_hdr));
+		qdf_mem_copy((char *)txdesc_hdr_ctl + sizeof(frm_hdr),
+					((void *)data +
+					 sizeof(struct ath_pktlog_hdr)),
+					 pl_hdr.size);
+		pl_hdr.size = log_size;
+		cds_pkt_stats_to_logger_thread(&pl_hdr, NULL,
+						txdesc_hdr_ctl);
+	}
+
+	if (pl_hdr.log_type == PKTLOG_TYPE_TX_STAT) {
+		struct ath_pktlog_tx_status txstat_log;
+		size_t log_size = pl_hdr.size;
+
+		txstat_log.ds_status = (void *)
+				       pktlog_getbuf(pl_dev, pl_info,
+						     log_size, &pl_hdr);
+		qdf_assert(txstat_log.ds_status);
+		qdf_mem_copy(txstat_log.ds_status,
+			     ((void *)data + sizeof(struct ath_pktlog_hdr)),
+			     pl_hdr.size);
+		cds_pkt_stats_to_logger_thread(&pl_hdr, NULL,
+						txstat_log.ds_status);
+	}
+	return A_OK;
+}
+
+#else
+A_STATUS process_tx_info(struct ol_txrx_pdev_t *txrx_pdev, void *data)
+{
+	/*
+	 * Must include to process different types
+	 * TX_CTL, TX_STATUS, TX_MSDU_ID, TX_FRM_HDR
+	 */
+	struct ol_pktlog_dev_t *pl_dev;
+	struct ath_pktlog_hdr pl_hdr;
+	struct ath_pktlog_info *pl_info;
+	uint32_t *pl_tgt_hdr;
+
+	if (!txrx_pdev) {
+		qdf_print("Invalid pdev in %s\n", __func__);
+		return A_ERROR;
+	}
+	qdf_assert(txrx_pdev->pl_dev);
+	qdf_assert(data);
+	pl_dev = txrx_pdev->pl_dev;
+
+	pl_tgt_hdr = (uint32_t *) data;
+	/*
+	 * Makes the short words (16 bits) portable b/w little endian
+	 * and big endian
+	 */
+	pl_hdr.flags = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_FLAGS_OFFSET) &
+			ATH_PKTLOG_HDR_FLAGS_MASK) >>
+		       ATH_PKTLOG_HDR_FLAGS_SHIFT;
+	pl_hdr.missed_cnt = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_MISSED_CNT_OFFSET) &
+			     ATH_PKTLOG_HDR_MISSED_CNT_MASK) >>
+			    ATH_PKTLOG_HDR_MISSED_CNT_SHIFT;
+	pl_hdr.log_type = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_LOG_TYPE_OFFSET) &
+			   ATH_PKTLOG_HDR_LOG_TYPE_MASK) >>
+			  ATH_PKTLOG_HDR_LOG_TYPE_SHIFT;
+	pl_hdr.size = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_SIZE_OFFSET) &
+		       ATH_PKTLOG_HDR_SIZE_MASK) >> ATH_PKTLOG_HDR_SIZE_SHIFT;
+	pl_hdr.timestamp = *(pl_tgt_hdr + ATH_PKTLOG_HDR_TIMESTAMP_OFFSET);
+
+	pl_info = pl_dev->pl_info;
+
+	if (pl_hdr.log_type == PKTLOG_TYPE_TX_FRM_HDR) {
+		/* Valid only for the TX CTL */
+		process_ieee_hdr(data + sizeof(pl_hdr));
+	}
+
+	if (pl_hdr.log_type == PKTLOG_TYPE_TX_VIRT_ADDR) {
+		A_UINT32 desc_id = (A_UINT32)
+				   *((A_UINT32 *) (data + sizeof(pl_hdr)));
+		A_UINT32 vdev_id = desc_id;
+
+		/* if the pkt log msg is for the bcn frame the vdev id
+		 * is piggybacked in desc_id and the MSB of the desc ID
+		 * would be set to FF
+		 */
+#define BCN_DESC_ID 0xFF
+		if ((desc_id >> 24) == BCN_DESC_ID) {
+			void *data;
+			A_UINT32 buf_size;
+
+			vdev_id &= 0x00FFFFFF;
+			data = wma_get_beacon_buffer_by_vdev_id(vdev_id,
+								&buf_size);
+			if (data) {
+				process_ieee_hdr(data);
+				qdf_mem_free(data);
+			}
+		} else {
+			/*
+			 * TODO: get the hdr content for mgmt frames from
+			 * Tx mgmt desc pool
+			 */
+		}
+	}
+
+	if (pl_hdr.log_type == PKTLOG_TYPE_TX_CTRL) {
+		struct ath_pktlog_txctl txctl_log;
+		size_t log_size = sizeof(txctl_log.priv);
+
+		txctl_log.txdesc_hdr_ctl = (void *)pktlog_getbuf(pl_dev,
+								 pl_info,
+								 log_size,
+								 &pl_hdr);
+
+		if (!txctl_log.txdesc_hdr_ctl) {
+			printk
+				("failed to get buf for txctl_log.txdesc_hdr_ctl\n");
+			return A_ERROR;
+		}
+
+		/*
+		 * frm hdr is currently Valid only for local frames
+		 * Add capability to include the fmr hdr for remote frames
+		 */
+		txctl_log.priv.frm_hdr = frm_hdr;
+		qdf_assert(txctl_log.priv.txdesc_ctl);
+		qdf_mem_copy((void *)&txctl_log.priv.txdesc_ctl,
+			     ((void *)data + sizeof(struct ath_pktlog_hdr)),
+			     pl_hdr.size);
+		qdf_assert(txctl_log.txdesc_hdr_ctl);
+		qdf_mem_copy(txctl_log.txdesc_hdr_ctl, &txctl_log.priv,
+			     sizeof(txctl_log.priv));
+		pl_hdr.size = log_size;
+		cds_pkt_stats_to_logger_thread(&pl_hdr, NULL,
+						txctl_log.txdesc_hdr_ctl);
+		/* Add Protocol information and HT specific information */
+	}
+
+	if (pl_hdr.log_type == PKTLOG_TYPE_TX_STAT) {
+		struct ath_pktlog_tx_status txstat_log;
+		size_t log_size = pl_hdr.size;
+
+		txstat_log.ds_status = (void *)
+				       pktlog_getbuf(pl_dev, pl_info, log_size, &pl_hdr);
+		qdf_assert(txstat_log.ds_status);
+		qdf_mem_copy(txstat_log.ds_status,
+			     ((void *)data + sizeof(struct ath_pktlog_hdr)),
+			     pl_hdr.size);
+		cds_pkt_stats_to_logger_thread(&pl_hdr, NULL,
+						txstat_log.ds_status);
+	}
+
+	if (pl_hdr.log_type == PKTLOG_TYPE_TX_MSDU_ID) {
+		struct ath_pktlog_msdu_info pl_msdu_info;
+		size_t log_size;
+
+		qdf_mem_set(&pl_msdu_info, sizeof(pl_msdu_info), 0);
+		log_size = sizeof(pl_msdu_info.priv);
+
+		if (pl_dev->mt_pktlog_enabled == false)
+			fill_ieee80211_hdr_data(txrx_pdev, &pl_msdu_info, data);
+
+		pl_msdu_info.ath_msdu_info = pktlog_getbuf(pl_dev, pl_info,
+							   log_size, &pl_hdr);
+		qdf_mem_copy((void *)&pl_msdu_info.priv.msdu_id_info,
+			     ((void *)data + sizeof(struct ath_pktlog_hdr)),
+			     sizeof(pl_msdu_info.priv.msdu_id_info));
+		qdf_mem_copy(pl_msdu_info.ath_msdu_info, &pl_msdu_info.priv,
+			     sizeof(pl_msdu_info.priv));
+		cds_pkt_stats_to_logger_thread(&pl_hdr, NULL,
+						pl_msdu_info.ath_msdu_info);
+	}
+	return A_OK;
+}
+#endif
+
+A_STATUS process_rx_info_remote(void *pdev, void *data)
+{
+	struct ol_pktlog_dev_t *pl_dev;
+	struct ath_pktlog_info *pl_info;
+	struct htt_host_rx_desc_base *rx_desc;
+	struct ath_pktlog_hdr pl_hdr;
+	struct ath_pktlog_rx_info rxstat_log;
+	size_t log_size;
+	struct ol_rx_remote_data *r_data = (struct ol_rx_remote_data *)data;
+	qdf_nbuf_t msdu;
+
+	if (!pdev) {
+		printk("Invalid pdev in %s\n", __func__);
+		return A_ERROR;
+	}
+	if (!r_data) {
+		printk("Invalid data in %s\n", __func__);
+		return A_ERROR;
+	}
+	pl_dev = ((struct ol_txrx_pdev_t *)pdev)->pl_dev;
+	pl_info = pl_dev->pl_info;
+	msdu = r_data->msdu;
+
+	while (msdu) {
+		rx_desc =
+		   (struct htt_host_rx_desc_base *)(qdf_nbuf_data(msdu)) - 1;
+		log_size =
+			sizeof(*rx_desc) - sizeof(struct htt_host_fw_desc_base);
+
+		/*
+		 * Construct the pktlog header pl_hdr
+		 * Because desc is DMA'd to the host memory
+		 */
+		pl_hdr.flags = (1 << PKTLOG_FLG_FRM_TYPE_REMOTE_S);
+		pl_hdr.missed_cnt = 0;
+#if defined(HELIUMPLUS)
+		pl_hdr.macId = r_data->mac_id;
+		pl_hdr.log_type = PKTLOG_TYPE_RX_STAT;
+		pl_hdr.flags |= PKTLOG_HDR_SIZE_16;
+#else
+		pl_hdr.log_type = PKTLOG_TYPE_RX_STAT;
+#endif
+		pl_hdr.size = sizeof(*rx_desc) -
+			      sizeof(struct htt_host_fw_desc_base);
+#if defined(HELIUMPLUS)
+		pl_hdr.timestamp =
+			rx_desc->ppdu_end.rx_pkt_end.phy_timestamp_1_lower_32;
+		pl_hdr.type_specific_data = 0xDEADAA;
+#else
+		pl_hdr.timestamp = rx_desc->ppdu_end.tsf_timestamp;
+#endif /* !defined(HELIUMPLUS) */
+		rxstat_log.rx_desc = (void *)pktlog_getbuf(pl_dev, pl_info,
+							   log_size, &pl_hdr);
+		qdf_mem_copy(rxstat_log.rx_desc, (void *)rx_desc +
+			     sizeof(struct htt_host_fw_desc_base), pl_hdr.size);
+		cds_pkt_stats_to_logger_thread(&pl_hdr, NULL,
+						rxstat_log.rx_desc);
+		msdu = qdf_nbuf_next(msdu);
+	}
+	return A_OK;
+}
+
+A_STATUS process_rx_info(void *pdev, void *data)
+{
+	struct ol_pktlog_dev_t *pl_dev;
+	struct ath_pktlog_info *pl_info;
+	struct ath_pktlog_rx_info rxstat_log;
+	struct ath_pktlog_hdr pl_hdr;
+	size_t log_size;
+	uint32_t *pl_tgt_hdr;
+
+	if (!pdev) {
+		printk("Invalid pdev in %s", __func__);
+		return A_ERROR;
+	}
+	pl_dev = ((struct ol_txrx_pdev_t *)pdev)->pl_dev;
+	pl_info = pl_dev->pl_info;
+	pl_tgt_hdr = (uint32_t *) data;
+	pl_hdr.flags = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_FLAGS_OFFSET) &
+			ATH_PKTLOG_HDR_FLAGS_MASK) >>
+		       ATH_PKTLOG_HDR_FLAGS_SHIFT;
+	pl_hdr.missed_cnt = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_MISSED_CNT_OFFSET) &
+			     ATH_PKTLOG_HDR_MISSED_CNT_MASK) >>
+			    ATH_PKTLOG_HDR_MISSED_CNT_SHIFT;
+#ifdef HELIUMPLUS
+	pl_hdr.log_type = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_LOG_TYPE_OFFSET) &
+			   ATH_PKTLOG_HDR_LOG_TYPE_MASK) >>
+			  ATH_PKTLOG_HDR_LOG_TYPE_SHIFT;
+	pl_hdr.macId = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_MAC_ID_OFFSET) &
+			   ATH_PKTLOG_HDR_MAC_ID_MASK) >>
+			  ATH_PKTLOG_HDR_MAC_ID_SHIFT;
+	pl_hdr.flags |= PKTLOG_HDR_SIZE_16;
+#else
+	pl_hdr.log_type = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_LOG_TYPE_OFFSET) &
+				   ATH_PKTLOG_HDR_LOG_TYPE_MASK) >>
+				  ATH_PKTLOG_HDR_LOG_TYPE_SHIFT;
+#endif
+
+	pl_hdr.size = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_SIZE_OFFSET) &
+		       ATH_PKTLOG_HDR_SIZE_MASK) >> ATH_PKTLOG_HDR_SIZE_SHIFT;
+	pl_hdr.timestamp = *(pl_tgt_hdr + ATH_PKTLOG_HDR_TIMESTAMP_OFFSET);
+	log_size = pl_hdr.size;
+	rxstat_log.rx_desc = (void *)pktlog_getbuf(pl_dev, pl_info,
+						   log_size, &pl_hdr);
+
+	qdf_mem_copy(rxstat_log.rx_desc,
+		     (void *)data + sizeof(struct ath_pktlog_hdr), pl_hdr.size);
+	cds_pkt_stats_to_logger_thread(&pl_hdr, NULL, rxstat_log.rx_desc);
+
+	return A_OK;
+}
+
+A_STATUS process_rate_find(void *pdev, void *data)
+{
+	struct ol_pktlog_dev_t *pl_dev;
+	struct ath_pktlog_hdr pl_hdr;
+	struct ath_pktlog_info *pl_info;
+	size_t log_size;
+
+	/*
+	 * Will be uncommented when the rate control find
+	 * for pktlog is implemented in the firmware.
+	 * Currently derived from the TX PPDU status
+	 */
+	struct ath_pktlog_rc_find rcf_log;
+	uint32_t *pl_tgt_hdr;
+
+	if (!pdev) {
+		qdf_print("Invalid pdev in %s\n", __func__);
+		return A_ERROR;
+	}
+	if (!data) {
+		qdf_print("Invalid data in %s\n", __func__);
+		return A_ERROR;
+	}
+
+	pl_tgt_hdr = (uint32_t *) data;
+	/*
+	 * Makes the short words (16 bits) portable b/w little endian
+	 * and big endian
+	 */
+	pl_hdr.flags = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_FLAGS_OFFSET) &
+			ATH_PKTLOG_HDR_FLAGS_MASK) >>
+		       ATH_PKTLOG_HDR_FLAGS_SHIFT;
+	pl_hdr.missed_cnt = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_MISSED_CNT_OFFSET) &
+			     ATH_PKTLOG_HDR_MISSED_CNT_MASK) >>
+			    ATH_PKTLOG_HDR_MISSED_CNT_SHIFT;
+#ifdef HELIUMPLUS
+	pl_hdr.log_type = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_LOG_TYPE_OFFSET) &
+			   ATH_PKTLOG_HDR_LOG_TYPE_MASK) >>
+			  ATH_PKTLOG_HDR_LOG_TYPE_SHIFT;
+	pl_hdr.macId = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_MAC_ID_OFFSET) &
+			   ATH_PKTLOG_HDR_MAC_ID_MASK) >>
+			  ATH_PKTLOG_HDR_MAC_ID_SHIFT;
+	pl_hdr.flags |= PKTLOG_HDR_SIZE_16;
+#else
+	pl_hdr.log_type = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_LOG_TYPE_OFFSET) &
+			   ATH_PKTLOG_HDR_LOG_TYPE_MASK) >>
+			  ATH_PKTLOG_HDR_LOG_TYPE_SHIFT;
+#endif
+
+	pl_hdr.size = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_SIZE_OFFSET) &
+		       ATH_PKTLOG_HDR_SIZE_MASK) >> ATH_PKTLOG_HDR_SIZE_SHIFT;
+	pl_hdr.timestamp = *(pl_tgt_hdr + ATH_PKTLOG_HDR_TIMESTAMP_OFFSET);
+	pl_dev = ((struct ol_txrx_pdev_t *)pdev)->pl_dev;
+	pl_info = pl_dev->pl_info;
+	log_size = pl_hdr.size;
+	rcf_log.rcFind = (void *)pktlog_getbuf(pl_dev, pl_info,
+					       log_size, &pl_hdr);
+
+	qdf_mem_copy(rcf_log.rcFind,
+				 ((char *)data + sizeof(struct ath_pktlog_hdr)),
+				 pl_hdr.size);
+	cds_pkt_stats_to_logger_thread(&pl_hdr, NULL, rcf_log.rcFind);
+
+	return A_OK;
+}
+
+A_STATUS process_sw_event(void *pdev, void *data)
+{
+	struct ol_pktlog_dev_t *pl_dev;
+	struct ath_pktlog_hdr pl_hdr;
+	struct ath_pktlog_info *pl_info;
+	size_t log_size;
+
+	/*
+	 * Will be uncommented when the rate control find
+	 * for pktlog is implemented in the firmware.
+	 * Currently derived from the TX PPDU status
+	 */
+	struct ath_pktlog_sw_event sw_event;
+	uint32_t *pl_tgt_hdr;
+
+	if (!pdev) {
+		qdf_print("Invalid pdev in %s\n", __func__);
+		return A_ERROR;
+	}
+	if (!data) {
+		qdf_print("Invalid data in %s\n", __func__);
+		return A_ERROR;
+	}
+
+	pl_tgt_hdr = (uint32_t *) data;
+	/*
+	 * Makes the short words (16 bits) portable b/w little endian
+	 * and big endian
+	 */
+	pl_hdr.flags = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_FLAGS_OFFSET) &
+			ATH_PKTLOG_HDR_FLAGS_MASK) >>
+		       ATH_PKTLOG_HDR_FLAGS_SHIFT;
+	pl_hdr.missed_cnt = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_MISSED_CNT_OFFSET) &
+			     ATH_PKTLOG_HDR_MISSED_CNT_MASK) >>
+			    ATH_PKTLOG_HDR_MISSED_CNT_SHIFT;
+#ifdef HELIUMPLUS
+	pl_hdr.log_type = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_LOG_TYPE_OFFSET) &
+			   ATH_PKTLOG_HDR_LOG_TYPE_MASK) >>
+			  ATH_PKTLOG_HDR_LOG_TYPE_SHIFT;
+	pl_hdr.macId = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_MAC_ID_OFFSET) &
+			   ATH_PKTLOG_HDR_MAC_ID_MASK) >>
+			  ATH_PKTLOG_HDR_MAC_ID_SHIFT;
+#else
+	pl_hdr.log_type = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_LOG_TYPE_OFFSET) &
+				   ATH_PKTLOG_HDR_LOG_TYPE_MASK) >>
+				  ATH_PKTLOG_HDR_LOG_TYPE_SHIFT;
+#endif
+
+	pl_hdr.size = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_SIZE_OFFSET) &
+		       ATH_PKTLOG_HDR_SIZE_MASK) >> ATH_PKTLOG_HDR_SIZE_SHIFT;
+	pl_hdr.timestamp = *(pl_tgt_hdr + ATH_PKTLOG_HDR_TIMESTAMP_OFFSET);
+
+#ifdef HELIUMPLUS
+	pl_hdr.type_specific_data =
+		*(pl_tgt_hdr + ATH_PKTLOG_HDR_TYPE_SPECIFIC_DATA_OFFSET);
+#endif
+
+	pl_dev = ((struct ol_txrx_pdev_t *)pdev)->pl_dev;
+	pl_info = pl_dev->pl_info;
+	log_size = pl_hdr.size;
+	sw_event.sw_event = (void *)pktlog_getbuf(pl_dev, pl_info,
+					       log_size, &pl_hdr);
+
+	qdf_mem_copy(sw_event.sw_event,
+				 ((char *)data + sizeof(struct ath_pktlog_hdr)),
+				 pl_hdr.size);
+
+	return A_OK;
+}
+
+A_STATUS process_rate_update(void *pdev, void *data)
+{
+	struct ol_pktlog_dev_t *pl_dev;
+	struct ath_pktlog_hdr pl_hdr;
+	size_t log_size;
+	struct ath_pktlog_info *pl_info;
+	struct ath_pktlog_rc_update rcu_log;
+	uint32_t *pl_tgt_hdr;
+
+	if (!pdev) {
+		printk("Invalid pdev in %s\n", __func__);
+		return A_ERROR;
+	}
+	if (!data) {
+		printk("Invalid data in %s\n", __func__);
+		return A_ERROR;
+	}
+	pl_tgt_hdr = (uint32_t *) data;
+	/*
+	 * Makes the short words (16 bits) portable b/w little endian
+	 * and big endian
+	 */
+	pl_hdr.flags = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_FLAGS_OFFSET) &
+			ATH_PKTLOG_HDR_FLAGS_MASK) >>
+		       ATH_PKTLOG_HDR_FLAGS_SHIFT;
+	pl_hdr.missed_cnt = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_MISSED_CNT_OFFSET) &
+			     ATH_PKTLOG_HDR_MISSED_CNT_MASK) >>
+			    ATH_PKTLOG_HDR_MISSED_CNT_SHIFT;
+#ifdef HELIUMPLUS
+	pl_hdr.log_type = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_LOG_TYPE_OFFSET) &
+			   ATH_PKTLOG_HDR_LOG_TYPE_MASK) >>
+			  ATH_PKTLOG_HDR_LOG_TYPE_SHIFT;
+	pl_hdr.macId = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_MAC_ID_OFFSET) &
+			   ATH_PKTLOG_HDR_MAC_ID_MASK) >>
+			  ATH_PKTLOG_HDR_MAC_ID_SHIFT;
+	pl_hdr.flags |= PKTLOG_HDR_SIZE_16;
+#else
+	pl_hdr.log_type = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_LOG_TYPE_OFFSET) &
+				   ATH_PKTLOG_HDR_LOG_TYPE_MASK) >>
+				  ATH_PKTLOG_HDR_LOG_TYPE_SHIFT;
+#endif
+
+	pl_hdr.size = (*(pl_tgt_hdr + ATH_PKTLOG_HDR_SIZE_OFFSET) &
+		       ATH_PKTLOG_HDR_SIZE_MASK) >> ATH_PKTLOG_HDR_SIZE_SHIFT;
+	pl_hdr.timestamp = *(pl_tgt_hdr + ATH_PKTLOG_HDR_TIMESTAMP_OFFSET);
+	pl_dev = ((struct ol_txrx_pdev_t *)pdev)->pl_dev;
+	log_size = pl_hdr.size;
+	pl_info = pl_dev->pl_info;
+
+	/*
+	 * Will be uncommented when the rate control update
+	 * for pktlog is implemented in the firmware.
+	 * Currently derived from the TX PPDU status
+	 */
+	rcu_log.txRateCtrl = (void *)pktlog_getbuf(pl_dev, pl_info,
+						   log_size, &pl_hdr);
+	qdf_mem_copy(rcu_log.txRateCtrl,
+		     ((char *)data + sizeof(struct ath_pktlog_hdr)),
+		     pl_hdr.size);
+	cds_pkt_stats_to_logger_thread(&pl_hdr, NULL, rcu_log.txRateCtrl);
+	return A_OK;
+}
+#endif /*REMOVE_PKT_LOG */