qcacld-2.0: Enhance DPTRACE to support RX path

Enahnce DPTRACE to support RX path and print
info in kmsg for DHCP and EAPOL packets

Change-Id: Ibbf57cf4b3de0ce45e9caeb408c12aa9241d404a
CRs-Fixed: 1008087

17 files changed, 274 insertions, 122 deletions

diff --git a/CORE/CLD_TXRX/HTT/htt_rx.c b/CORE/CLD_TXRX/HTT/htt_rx.c
index 3fe3ad69ad5a..ba34bce3caca 100644
--- a/CORE/CLD_TXRX/HTT/htt_rx.c
+++ b/CORE/CLD_TXRX/HTT/htt_rx.c
@@ -50,6 +50,7 @@
 #include <ol_htt_rx_api.h>
 #include <htt_internal.h> /* HTT_ASSERT, htt_pdev_t, HTT_RX_BUF_SIZE */
 #include "regtable.h"
+#include "adf_trace.h"
 
 #include <ieee80211_common.h>         /* ieee80211_frame, ieee80211_qoscntl */
 #include <ieee80211_defines.h> /* ieee80211_rx_status */
@@ -1858,6 +1859,8 @@ htt_rx_amsdu_rx_in_order_pop_ll(
     /* Get the total number of MSDUs */
     msdu_count = HTT_RX_IN_ORD_PADDR_IND_MSDU_CNT_GET(*(msg_word + 1));
     HTT_RX_CHECK_MSDU_COUNT(msdu_count);
+    peer_id = HTT_RX_IN_ORD_PADDR_IND_PEER_ID_GET(
+                                 *(u_int32_t *)rx_ind_data);
 
     msg_word = (u_int32_t *)(rx_ind_data + HTT_RX_IN_ORD_PADDR_IND_HDR_BYTES);
     if (offload_ind) {
@@ -1899,6 +1902,14 @@ htt_rx_amsdu_rx_in_order_pop_ll(
          */
         adf_nbuf_pull_head(msdu, HTT_RX_STD_DESC_RESERVATION);
 
+        adf_dp_trace_set_track(msdu, ADF_RX);
+        ADF_NBUF_CB_RX_PACKET_TRACE(msdu) = NBUF_TX_PKT_DATA_TRACK;
+        ol_rx_log_packet(pdev, peer_id, msdu);
+        DPTRACE(adf_dp_trace(msdu,
+                ADF_DP_TRACE_RX_HTT_PACKET_PTR_RECORD,
+                adf_nbuf_data_addr(msdu),
+                sizeof(adf_nbuf_data(msdu)), ADF_RX));
+
         adf_nbuf_trim_tail(
            msdu, HTT_RX_BUF_SIZE - (RX_STD_DESC_SIZE +
                               HTT_RX_IN_ORD_PADDR_IND_MSDU_LEN_GET(*(msg_word + 1))));
@@ -1916,8 +1927,7 @@ htt_rx_amsdu_rx_in_order_pop_ll(
         msdu_count--;
 
         /* calling callback function for packet logging */
-        peer_id = HTT_RX_IN_ORD_PADDR_IND_PEER_ID_GET(
-                                 *(u_int32_t *)rx_ind_data);
+
         if (adf_os_unlikely((*((u_int8_t *) &rx_desc->fw_desc.u.val)) &
                     FW_RX_DESC_MIC_ERR_M))
             status = RX_PKT_FATE_FW_DROP_INVALID;
diff --git a/CORE/CLD_TXRX/HTT/htt_tx.c b/CORE/CLD_TXRX/HTT/htt_tx.c
index 3a2fa5e0b3d0..392424f05948 100644
--- a/CORE/CLD_TXRX/HTT/htt_tx.c
+++ b/CORE/CLD_TXRX/HTT/htt_tx.c
@@ -475,7 +475,7 @@ htt_tx_send_std(
     NBUF_UPDATE_TX_PKT_COUNT(msdu, NBUF_TX_PKT_HTT);
     DPTRACE(adf_dp_trace(msdu, ADF_DP_TRACE_HTT_PACKET_PTR_RECORD,
                 adf_nbuf_data_addr(msdu),
-                sizeof(adf_nbuf_data(msdu))));
+                sizeof(adf_nbuf_data(msdu)), ADF_TX));
 
     if (adf_nbuf_queue_len(&pdev->txnbufq) > 0) {
         HTT_TX_NBUF_QUEUE_ADD(pdev, msdu);
diff --git a/CORE/CLD_TXRX/TXRX/ol_rx.c b/CORE/CLD_TXRX/TXRX/ol_rx.c
index 769e72b522b0..0c452fd55805 100644
--- a/CORE/CLD_TXRX/TXRX/ol_rx.c
+++ b/CORE/CLD_TXRX/TXRX/ol_rx.c
@@ -60,6 +60,7 @@
 #include <ol_vowext_dbg_defs.h>
 #include <wma.h>
 #include "pktlog_ac_fmt.h"
+#include "adf_trace.h"
 
 #ifdef HTT_RX_RESTORE
 #include "vos_cnss.h"
@@ -1317,6 +1318,11 @@ ol_rx_in_order_deliver(
     while (msdu) {
         adf_nbuf_t next = adf_nbuf_next(msdu);
 
+        DPTRACE(adf_dp_trace(msdu,
+                ADF_DP_TRACE_RX_TXRX_PACKET_PTR_RECORD,
+                adf_nbuf_data_addr(msdu),
+                sizeof(adf_nbuf_data(msdu)), ADF_RX));
+
         OL_RX_PEER_STATS_UPDATE(peer, msdu);
         OL_RX_ERR_STATISTICS_1(vdev->pdev, vdev, peer, rx_desc, OL_RX_ERR_NONE);
         TXRX_STATS_MSDU_INCR(vdev->pdev, rx.delivered, msdu);
@@ -1333,6 +1339,24 @@ ol_rx_in_order_deliver(
     OL_RX_OSIF_DELIVER(vdev, peer, msdu_list);
 }
 
+/**
+ * ol_rx_log_packet() - log rx packet
+ * @htt_pdev: htt pdev
+ * @peer_id: peer_id
+ * @msdu: skb
+ *
+ * Return: none
+ */
+void ol_rx_log_packet(htt_pdev_handle htt_pdev,
+                      uint8_t peer_id, adf_nbuf_t msdu)
+{
+    struct ol_txrx_peer_t *peer;
+
+    peer = ol_txrx_peer_find_by_id(htt_pdev->txrx_pdev, peer_id);
+    if (peer)
+        adf_dp_trace_log_pkt(peer->vdev->vdev_id, msdu, ADF_RX);
+}
+
 void
 ol_rx_offload_paddr_deliver_ind_handler(
    htt_pdev_handle htt_pdev,
@@ -1353,6 +1377,13 @@ ol_rx_offload_paddr_deliver_ind_handler(
 
         peer = ol_txrx_peer_find_by_id(htt_pdev->txrx_pdev, peer_id);
         if (peer && peer->vdev) {
+            adf_dp_trace_set_track(head_buf, ADF_RX);
+            adf_dp_trace_log_pkt(peer->vdev->vdev_id,
+                                 head_buf, ADF_RX);
+            DPTRACE(adf_dp_trace(head_buf,
+                    ADF_DP_TRACE_RX_OFFLOAD_HTT_PACKET_PTR_RECORD,
+                    adf_nbuf_data_addr(head_buf),
+                    sizeof(adf_nbuf_data(head_buf)), ADF_RX));
             vdev = peer->vdev;
             OL_RX_OSIF_DELIVER(vdev, peer, head_buf);
         } else {
diff --git a/CORE/CLD_TXRX/TXRX/ol_rx.h b/CORE/CLD_TXRX/TXRX/ol_rx.h
index b1890025ed30..19676a626306 100644
--- a/CORE/CLD_TXRX/TXRX/ol_rx.h
+++ b/CORE/CLD_TXRX/TXRX/ol_rx.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2014 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011, 2014, 2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -63,6 +63,9 @@ ol_rx_in_order_deliver(
     unsigned tid,
     adf_nbuf_t head_msdu);
 
+void ol_rx_log_packet(htt_pdev_handle htt_pdev,
+    uint8_t peer_id, adf_nbuf_t msdu);
+
 void
 ol_rx_offload_paddr_deliver_ind_handler(
    htt_pdev_handle htt_pdev,
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx.c b/CORE/CLD_TXRX/TXRX/ol_tx.c
index f55ddfe9efd1..a2bd003e2502 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx.c
+++ b/CORE/CLD_TXRX/TXRX/ol_tx.c
@@ -111,7 +111,7 @@ ol_tx_ll(ol_txrx_vdev_handle vdev, adf_nbuf_t msdu_list)
          * tx_send call.
          */
         next = adf_nbuf_next(msdu);
-        ol_tx_send(vdev->pdev, tx_desc, msdu);
+        ol_tx_send(vdev->pdev, tx_desc, msdu, vdev->vdev_id);
         msdu = next;
     }
     return NULL; /* all MSDUs were accepted */
@@ -242,7 +242,7 @@ ol_tx_vdev_pause_queue_append(
         DPTRACE(adf_dp_trace(msdu_list,
                 ADF_DP_TRACE_TXRX_QUEUE_PACKET_PTR_RECORD,
                 adf_nbuf_data_addr(msdu_list),
-                sizeof(adf_nbuf_data(msdu_list))));
+                sizeof(adf_nbuf_data(msdu_list)), ADF_TX));
 
         vdev->ll_pause.txq.depth++;
         if (!vdev->ll_pause.txq.head) {
@@ -514,7 +514,7 @@ ol_tx_non_std_ll(
          * downloaded to the target via the HTT tx descriptor.
          */
         htt_tx_desc_display(tx_desc->htt_tx_desc);
-        ol_tx_send(vdev->pdev, tx_desc, msdu);
+        ol_tx_send(vdev->pdev, tx_desc, msdu, vdev->vdev_id);
         msdu = next;
     }
     return NULL; /* all MSDUs were accepted */
@@ -1275,7 +1275,7 @@ adf_nbuf_t ol_tx_reinject(
 
     htt_tx_desc_set_peer_id(tx_desc->htt_tx_desc, peer_id);
 
-    ol_tx_send(vdev->pdev, tx_desc, msdu);
+    ol_tx_send(vdev->pdev, tx_desc, msdu, vdev->vdev_id);
 
     return NULL;
 }
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx_send.c b/CORE/CLD_TXRX/TXRX/ol_tx_send.c
index b35dc99af25c..8616dea07206 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx_send.c
+++ b/CORE/CLD_TXRX/TXRX/ol_tx_send.c
@@ -211,7 +211,7 @@ void
 ol_tx_send(
     struct ol_txrx_pdev_t *pdev,
     struct ol_tx_desc_t *tx_desc,
-    adf_nbuf_t msdu)
+    adf_nbuf_t msdu, uint8_t vdev_id)
 {
     int msdu_credit_consumed;
     u_int16_t id;
@@ -222,7 +222,7 @@ ol_tx_send(
     NBUF_UPDATE_TX_PKT_COUNT(msdu, NBUF_TX_PKT_TXRX);
     DPTRACE(adf_dp_trace_ptr(msdu, ADF_DP_TRACE_TXRX_PACKET_PTR_RECORD,
                 adf_nbuf_data_addr(msdu),
-                sizeof(adf_nbuf_data(msdu)), tx_desc->id, 0));
+                sizeof(adf_nbuf_data(msdu)), tx_desc->id, vdev_id));
 
     failed = htt_tx_send_std(pdev->htt_pdev, msdu, id);
     if (adf_os_unlikely(failed)) {
diff --git a/CORE/CLD_TXRX/TXRX/ol_tx_send.h b/CORE/CLD_TXRX/TXRX/ol_tx_send.h
index 2d20da995b4d..5eb08abd34ad 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx_send.h
+++ b/CORE/CLD_TXRX/TXRX/ol_tx_send.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011, 2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -60,7 +60,7 @@ void
 ol_tx_send(
     struct ol_txrx_pdev_t *pdev,
     struct ol_tx_desc_t *tx_desc,
-    adf_nbuf_t msdu);
+    adf_nbuf_t msdu, uint8_t vdev_id);
 
 /**
  * @brief Send a tx batch download to the target.
diff --git a/CORE/HDD/src/wlan_hdd_hostapd.c b/CORE/HDD/src/wlan_hdd_hostapd.c
index f229cca33d93..62cb37d28e84 100644
--- a/CORE/HDD/src/wlan_hdd_hostapd.c
+++ b/CORE/HDD/src/wlan_hdd_hostapd.c
@@ -120,7 +120,6 @@ extern int process_wma_set_command(int sessid, int paramid,
 /* EID byte + length byte + four byte WiFi OUI */
 #define DOT11F_EID_HEADER_LEN (6)
 
-#define DUMP_DP_TRACE       0
 
 /*---------------------------------------------------------------------------
  *   Function definitions
@@ -2638,6 +2637,10 @@ static int __iw_softap_set_two_ints_getnone(struct net_device *dev,
             value[1], value[2]);
         if (value[1] == DUMP_DP_TRACE)
             adf_dp_trace_dump_all(value[2]);
+        else if (value[1] == ENABLE_DP_TRACE_LIVE_MODE)
+            adf_dp_trace_enable_live_mode();
+        else if (value[1] == CLEAR_DP_TRACE_BUFFER)
+            adf_dp_trace_clear_buffer();
         else
             hddLog(LOGE, "unexpected value for dump_dp_trace");
         break;
diff --git a/CORE/HDD/src/wlan_hdd_softap_tx_rx.c b/CORE/HDD/src/wlan_hdd_softap_tx_rx.c
index e0adb662ee3a..abccb6fe25c6 100644
--- a/CORE/HDD/src/wlan_hdd_softap_tx_rx.c
+++ b/CORE/HDD/src/wlan_hdd_softap_tx_rx.c
@@ -390,15 +390,15 @@ int __hdd_softap_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
        NBUF_SET_PACKET_TRACK(skb, NBUF_TX_PKT_DATA_TRACK);
        NBUF_UPDATE_TX_PKT_COUNT(skb, NBUF_TX_PKT_HDD);
 
-       adf_dp_trace_set_track(skb);
-       DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_HDD_PACKET_PTR_RECORD,
-                  (uint8_t *)&skb->data, sizeof(skb->data)));
-       DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_HDD_PACKET_RECORD,
-                  (uint8_t *)skb->data, skb->len));
+       adf_dp_trace_set_track(skb, ADF_TX);
+       DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_HDD_TX_PACKET_PTR_RECORD,
+                  (uint8_t *)&skb->data, sizeof(skb->data), ADF_TX));
+       DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_HDD_TX_PACKET_RECORD,
+                  (uint8_t *)skb->data, skb->len, ADF_TX));
        if (skb->len > ADF_DP_TRACE_RECORD_SIZE)
-            DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_HDD_PACKET_RECORD,
+            DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_HDD_TX_PACKET_RECORD,
                   (uint8_t *)&skb->data[ADF_DP_TRACE_RECORD_SIZE],
-                  (skb->len - ADF_DP_TRACE_RECORD_SIZE)));
+                  (skb->len - ADF_DP_TRACE_RECORD_SIZE), ADF_TX));
 
        skb = skb_next;
        continue;
@@ -468,7 +468,7 @@ static void __hdd_softap_tx_timeout(struct net_device *dev)
    int i = 0;
 
    DPTRACE(adf_dp_trace(NULL, ADF_DP_TRACE_HDD_SOFTAP_TX_TIMEOUT,
-                        NULL, 0));
+                        NULL, 0, ADF_TX));
 
    hdd_ctx = WLAN_HDD_GET_CTX(adapter);
    if (hdd_ctx->isLogpInProgress) {
@@ -835,8 +835,11 @@ VOS_STATUS hdd_softap_rx_packet_cbk(v_VOID_t *vosContext,
       ++pAdapter->stats.rx_packets;
       pAdapter->stats.rx_bytes += skb->len;
 
-      adf_dp_trace_log_pkt(pAdapter->sessionId, skb,
-          WIFI_EVENT_DRIVER_EAPOL_FRAME_RECEIVED);
+      DPTRACE(adf_dp_trace(rxBuf,
+              ADF_DP_TRACE_RX_HDD_PACKET_PTR_RECORD,
+              adf_nbuf_data_addr(rxBuf),
+              sizeof(adf_nbuf_data(rxBuf)), ADF_RX));
+
 #ifdef QCA_PKT_PROTO_TRACE
       if ((pHddCtx->cfg_ini->gEnableDebugLog & VOS_PKT_TRAC_TYPE_EAPOL) ||
           (pHddCtx->cfg_ini->gEnableDebugLog & VOS_PKT_TRAC_TYPE_DHCP)) {
diff --git a/CORE/HDD/src/wlan_hdd_tx_rx.c b/CORE/HDD/src/wlan_hdd_tx_rx.c
index 7cd0b3f1a2b0..f5df394f8927 100644
--- a/CORE/HDD/src/wlan_hdd_tx_rx.c
+++ b/CORE/HDD/src/wlan_hdd_tx_rx.c
@@ -358,11 +358,11 @@ void hdd_tx_resume_cb(void *adapter_context,
 void hdd_drop_skb(hdd_adapter_t *adapter, struct sk_buff *skb)
 {
 	DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_DROP_PACKET_RECORD,
-			(uint8_t *)skb->data, skb->len));
+			(uint8_t *)skb->data, skb->len, ADF_TX));
 	if (skb->len > ADF_DP_TRACE_RECORD_SIZE)
 		DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_DROP_PACKET_RECORD,
 				(uint8_t *)&skb->data[ADF_DP_TRACE_RECORD_SIZE],
-				(skb->len - ADF_DP_TRACE_RECORD_SIZE)));
+				(skb->len - ADF_DP_TRACE_RECORD_SIZE), ADF_TX));
 
 	++adapter->stats.tx_dropped;
 	++adapter->hdd_stats.hddTxRxStats.txXmitDropped;
@@ -385,12 +385,12 @@ void hdd_drop_skb_list(hdd_adapter_t *adapter, struct sk_buff *skb,
 
 	while (skb) {
 		DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_DROP_PACKET_RECORD,
-				(uint8_t *)skb->data, skb->len));
+				(uint8_t *)skb->data, skb->len, ADF_TX));
 		if (skb->len > ADF_DP_TRACE_RECORD_SIZE)
 			DPTRACE(adf_dp_trace(skb,
 				ADF_DP_TRACE_DROP_PACKET_RECORD,
 				(uint8_t *)&skb->data[ADF_DP_TRACE_RECORD_SIZE],
-				(skb->len - ADF_DP_TRACE_RECORD_SIZE)));
+				(skb->len - ADF_DP_TRACE_RECORD_SIZE), ADF_TX));
 
 		++adapter->stats.tx_dropped;
 		++adapter->hdd_stats.hddTxRxStats.txXmitDropped;
@@ -633,20 +633,19 @@ int __hdd_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
            list_tail = list_tail->next;
        }
        vos_mem_zero(skb->cb, sizeof(skb->cb));
-       adf_dp_trace_log_pkt(pAdapter->sessionId, skb,
-           WIFI_EVENT_DRIVER_EAPOL_FRAME_TRANSMIT_REQUESTED);
+       adf_dp_trace_log_pkt(pAdapter->sessionId, skb, ADF_TX);
        NBUF_SET_PACKET_TRACK(skb, NBUF_TX_PKT_DATA_TRACK);
        NBUF_UPDATE_TX_PKT_COUNT(skb, NBUF_TX_PKT_HDD);
 
-       adf_dp_trace_set_track(skb);
-       DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_HDD_PACKET_PTR_RECORD,
-                 (uint8_t *)&skb->data, sizeof(skb->data)));
-       DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_HDD_PACKET_RECORD,
-                 (uint8_t *)skb->data, skb->len));
+       adf_dp_trace_set_track(skb, ADF_TX);
+       DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_HDD_TX_PACKET_PTR_RECORD,
+                 (uint8_t *)&skb->data, sizeof(skb->data), ADF_TX));
+       DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_HDD_TX_PACKET_RECORD,
+                 (uint8_t *)skb->data, skb->len, ADF_TX));
        if (skb->len > ADF_DP_TRACE_RECORD_SIZE)
-           DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_HDD_PACKET_RECORD,
+           DPTRACE(adf_dp_trace(skb, ADF_DP_TRACE_HDD_TX_PACKET_RECORD,
                       (uint8_t *)&skb->data[ADF_DP_TRACE_RECORD_SIZE],
-                      (skb->len - ADF_DP_TRACE_RECORD_SIZE)));
+                      (skb->len - ADF_DP_TRACE_RECORD_SIZE), ADF_TX));
        skb = skb_next;
        continue;
 
@@ -824,7 +823,7 @@ static void __hdd_tx_timeout(struct net_device *dev)
    hddLog(LOGE, FL("Transmission timeout occurred jiffies %lu trans_start %lu"),
           jiffies, dev->trans_start);
    DPTRACE(adf_dp_trace(NULL, ADF_DP_TRACE_HDD_TX_TIMEOUT,
-                        NULL, 0));
+                        NULL, 0, ADF_TX));
    /*
     * Getting here implies we disabled the TX queues for too long. Queues are
     * disabled either because of disassociation or low resource scenarios. In
@@ -1229,8 +1228,10 @@ VOS_STATUS hdd_rx_packet_cbk(v_VOID_t *vosContext,
             continue;
       }
 
-      adf_dp_trace_log_pkt(pAdapter->sessionId, skb,
-          WIFI_EVENT_DRIVER_EAPOL_FRAME_RECEIVED);
+      DPTRACE(adf_dp_trace(rxBuf,
+              ADF_DP_TRACE_RX_HDD_PACKET_PTR_RECORD,
+              adf_nbuf_data_addr(rxBuf),
+              sizeof(adf_nbuf_data(rxBuf)), ADF_RX));
 
 #ifdef QCA_PKT_PROTO_TRACE
       if ((pHddCtx->cfg_ini->gEnableDebugLog & VOS_PKT_TRAC_TYPE_EAPOL) ||
diff --git a/CORE/HDD/src/wlan_hdd_wext.c b/CORE/HDD/src/wlan_hdd_wext.c
index 095f04419ad6..fd738dac6bce 100644
--- a/CORE/HDD/src/wlan_hdd_wext.c
+++ b/CORE/HDD/src/wlan_hdd_wext.c
@@ -458,7 +458,6 @@ static const hdd_freq_chan_map_t freq_chan_map[] = { {2412, 1}, {2417, 2},
 #endif
 #define WE_SET_MON_MODE_CHAN 3
 #define WE_DUMP_DP_TRACE_LEVEL    4
-#define DUMP_DP_TRACE       0
 
 #define WLAN_STATS_INVALID            0
 #define WLAN_STATS_RETRY_CNT          1
@@ -11367,6 +11366,10 @@ static int __iw_set_two_ints_getnone(struct net_device *dev,
                        value[1], value[2]);
         if (value[1] == DUMP_DP_TRACE)
             adf_dp_trace_dump_all(value[2]);
+        else if (value[1] == ENABLE_DP_TRACE_LIVE_MODE)
+            adf_dp_trace_enable_live_mode();
+        else if (value[1] == CLEAR_DP_TRACE_BUFFER)
+            adf_dp_trace_clear_buffer();
         else
             hddLog(LOGE, "unexpected value for dump_dp_trace");
         break;
diff --git a/CORE/SERVICES/COMMON/adf/adf_trace.c b/CORE/SERVICES/COMMON/adf/adf_trace.c
index 8311147a7aec..0a4fddb95ff3 100644
--- a/CORE/SERVICES/COMMON/adf/adf_trace.c
+++ b/CORE/SERVICES/COMMON/adf/adf_trace.c
@@ -75,9 +75,10 @@ void adf_dp_trace_init(void)
 	g_adf_dp_trace_data.head = INVALID_ADF_DP_TRACE_ADDR;
 	g_adf_dp_trace_data.tail = INVALID_ADF_DP_TRACE_ADDR;
 	g_adf_dp_trace_data.num = 0;
-	g_adf_dp_trace_data.proto_bitmap = 0;
+	g_adf_dp_trace_data.proto_bitmap = NBUF_PKT_TRAC_TYPE_DHCP |
+			NBUF_PKT_TRAC_TYPE_EAPOL;
 	g_adf_dp_trace_data.no_of_record = 0;
-	g_adf_dp_trace_data.verbosity    = ADF_DP_TRACE_VERBOSITY_DEFAULT;
+	g_adf_dp_trace_data.verbosity    = ADF_DP_TRACE_VERBOSITY_LOW;
 	g_adf_dp_trace_data.enable = true;
 
 	for (i = 0; i < ADF_DP_TRACE_MAX; i++)
@@ -155,17 +156,26 @@ uint8_t adf_dp_get_proto_bitmap(void)
 /**
  * adf_dp_trace_set_track() - Marks whether the packet needs to be traced
  * @nbuf  : defines the netbuf
+ * @dir: direction
  *
  * Return: None
  */
-void adf_dp_trace_set_track(adf_nbuf_t nbuf)
+void adf_dp_trace_set_track(adf_nbuf_t nbuf,  enum adf_proto_dir dir)
 {
+	uint32_t count = 0;
+
 	spin_lock_bh(&l_dp_trace_lock);
-	g_adf_dp_trace_data.count++;
+	if (ADF_TX == dir)
+		count = ++g_adf_dp_trace_data.tx_count;
+	else if (ADF_RX == dir)
+		count = ++g_adf_dp_trace_data.rx_count;
+
 	if ((g_adf_dp_trace_data.no_of_record != 0) &&
-	    (g_adf_dp_trace_data.count %
-			g_adf_dp_trace_data.no_of_record == 0)) {
-		ADF_NBUF_SET_DP_TRACE(nbuf, 1);
+		(count % g_adf_dp_trace_data.no_of_record == 0)) {
+		if (ADF_TX == dir)
+			ADF_NBUF_CB_TX_DP_TRACE(nbuf) = 1;
+		else if (ADF_RX == dir)
+			ADF_NBUF_CB_RX_DP_TRACE(nbuf) = 1;
 	}
 	spin_unlock_bh(&l_dp_trace_lock);
 }
@@ -183,10 +193,10 @@ static void dump_hex_trace(char *str, uint8_t *buf, uint8_t buf_len)
 	uint8_t i;
 
 	/* Dump the bytes in the last line */
-	printk("%s: ", str);
+	adf_os_print("%s: ", str);
 	for (i = 0; i < buf_len; i++)
-		printk("%02x ", buf[i]);
-	printk("\n");
+		adf_os_print("%02x ", buf[i]);
+	adf_os_print("\n");
 }
 
 /**
@@ -206,32 +216,40 @@ const char *adf_dp_code_to_string(enum ADF_DP_TRACE_ID code)
 		return "DHCP:";
 	case ADF_DP_TRACE_ARP_PACKET_RECORD:
 		return "ARP:";
-	case ADF_DP_TRACE_HDD_PACKET_PTR_RECORD:
-		return "HDD: PTR:";
-	case ADF_DP_TRACE_HDD_PACKET_RECORD:
-		return "HDD: DATA:";
+	case ADF_DP_TRACE_HDD_TX_PACKET_PTR_RECORD:
+		return "HDD: TX: PTR:";
+	case ADF_DP_TRACE_HDD_TX_PACKET_RECORD:
+		return "HDD: TX: DATA:";
 	case ADF_DP_TRACE_CE_PACKET_PTR_RECORD:
-		return "CE: PTR:";
+		return "CE: TX: PTR:";
 	case ADF_DP_TRACE_CE_FAST_PACKET_PTR_RECORD:
-		return "CE:F: PTR:";
+		return "CE: TX: FAST: PTR:";
 	case ADF_DP_TRACE_FREE_PACKET_PTR_RECORD:
-		return "FREE: PTR:";
+		return "FREE: TX: PTR:";
+	case ADF_DP_TRACE_RX_HTT_PACKET_PTR_RECORD:
+		return "HTT: RX: PTR:";
+	case ADF_DP_TRACE_RX_OFFLOAD_HTT_PACKET_PTR_RECORD:
+		return "HTT: RX: OF: PTR:";
+	case ADF_DP_TRACE_RX_HDD_PACKET_PTR_RECORD:
+		return "HDD: RX: PTR:";
 	case ADF_DP_TRACE_TXRX_QUEUE_PACKET_PTR_RECORD:
-		return "TX:Q: PTR:";
+		return "TXRX: TX: Q: PTR:";
 	case ADF_DP_TRACE_TXRX_PACKET_PTR_RECORD:
-		return "TX: PTR:";
+		return "TXRX: TX: PTR:";
 	case ADF_DP_TRACE_TXRX_FAST_PACKET_PTR_RECORD:
-		return "TX:F: PTR:";
+		return "TXRX: TX: FAST: PTR:";
 	case ADF_DP_TRACE_HTT_PACKET_PTR_RECORD:
-		return "HTT: PTR:";
+		return "HTT: TX: PTR:";
 	case ADF_DP_TRACE_HTC_PACKET_PTR_RECORD:
-		return "HTC: PTR:";
+		return "HTC: TX: PTR:";
 	case ADF_DP_TRACE_HIF_PACKET_PTR_RECORD:
-		return "HIF: PTR:";
+		return "HIF: TX: PTR:";
+	case ADF_DP_TRACE_RX_TXRX_PACKET_PTR_RECORD:
+		return "TXRX: RX: PTR:";
 	case ADF_DP_TRACE_HDD_TX_TIMEOUT:
-		return "STA: TO:";
+		return "HDD: STA: TO:";
 	case ADF_DP_TRACE_HDD_SOFTAP_TX_TIMEOUT:
-		return "SAP: TO:";
+		return "HDD: SAP: TO:";
 	default:
 		return "Invalid";
 	}
@@ -247,9 +265,9 @@ const char *adf_dp_dir_to_str(enum adf_proto_dir dir)
 {
 	switch (dir) {
 	case ADF_TX:
-		return "->";
+		return " --> ";
 	case ADF_RX:
-		return "<-";
+		return " <-- ";
 	default:
 		return "invalid";
 	}
@@ -324,7 +342,8 @@ const char *adf_dp_subtype_to_str(enum adf_proto_subtype subtype)
  *
  * Return: true/false
  */
-bool adf_dp_enable_check(adf_nbuf_t nbuf, enum ADF_DP_TRACE_ID code)
+bool adf_dp_enable_check(adf_nbuf_t nbuf, enum ADF_DP_TRACE_ID code,
+		enum adf_proto_dir dir)
 {
 	/* Return when Dp trace is not enabled */
 	if (!g_adf_dp_trace_data.enable)
@@ -335,7 +354,8 @@ bool adf_dp_enable_check(adf_nbuf_t nbuf, enum ADF_DP_TRACE_ID code)
 
 	if ((nbuf) && ((NBUF_GET_PACKET_TRACK(nbuf) !=
 		 NBUF_TX_PKT_DATA_TRACK) ||
-		 (!ADF_NBUF_GET_DP_TRACE(nbuf))))
+		 ((dir == ADF_TX) && (ADF_NBUF_CB_TX_DP_TRACE(nbuf) == 0)) ||
+		 ((dir == ADF_RX) && (ADF_NBUF_CB_RX_DP_TRACE(nbuf) == 0))))
 		return false;
 
 	return true;
@@ -346,13 +366,15 @@ bool adf_dp_enable_check(adf_nbuf_t nbuf, enum ADF_DP_TRACE_ID code)
  * @code: dptrace code
  * @data: data pointer
  * @size: size of buffer
+ * @print: print it in kmsg
  *
  * Return: none
  */
 void adf_dp_add_record(enum ADF_DP_TRACE_ID code,
-		       uint8_t *data, uint8_t size)
+		       uint8_t *data, uint8_t size, bool print)
 {
 	struct adf_dp_trace_record_s *rec = NULL;
+	int index;
 
 	spin_lock_bh(&l_dp_trace_lock);
 
@@ -381,6 +403,7 @@ void adf_dp_add_record(enum ADF_DP_TRACE_ID code,
 	}
 
 	rec = &g_adf_dp_trace_tbl[g_adf_dp_trace_data.tail];
+	index = g_adf_dp_trace_data.tail;
 	rec->code = code;
 	rec->size = 0;
 	if (data != NULL && size > 0) {
@@ -394,18 +417,21 @@ void adf_dp_add_record(enum ADF_DP_TRACE_ID code,
 	rec->time = adf_os_gettimestamp();
 	rec->pid = (in_interrupt() ? 0 : current->pid);
 	spin_unlock_bh(&l_dp_trace_lock);
+
+	if (g_adf_dp_trace_data.live_mode || print == true)
+		adf_dp_trace_cb_table[rec->code] (rec, index);
 }
 
 /**
  * adf_log_eapol_pkt() - log EAPOL packet
  * @session_id: vdev_id
  * @skb: skb pointer
- * @event_type: event_type
+ * @dir: direction
  *
  * Return: true/false
  */
 bool adf_log_eapol_pkt(uint8_t session_id, struct sk_buff *skb,
-		       uint8_t event_type)
+		       enum adf_proto_dir dir)
 {
 	enum adf_proto_subtype subtype;
 
@@ -417,9 +443,11 @@ bool adf_log_eapol_pkt(uint8_t session_id, struct sk_buff *skb,
 			session_id, (skb->data + ADF_NBUF_SRC_MAC_OFFSET),
 			(skb->data + ADF_NBUF_DEST_MAC_OFFSET),
 			ADF_PROTO_TYPE_EAPOL, subtype,
-			event_type == ADF_RX ?
-			 ADF_RX : ADF_TX));
-		ADF_NBUF_SET_DP_TRACE(skb, 1);
+			dir));
+		if (ADF_TX == dir)
+			ADF_NBUF_CB_TX_DP_TRACE(skb) = 1;
+		else if (ADF_RX == dir)
+			ADF_NBUF_CB_RX_DP_TRACE(skb) = 1;
 		return true;
 	}
 	return false;
@@ -429,12 +457,12 @@ bool adf_log_eapol_pkt(uint8_t session_id, struct sk_buff *skb,
  * adf_log_dhcp_pkt() - log DHCP packet
  * @session_id: vdev_id
  * @skb: skb pointer
- * @event_type: event_type
+ * @dir: direction
  *
  * Return: true/false
  */
 bool adf_log_dhcp_pkt(uint8_t session_id, struct sk_buff *skb,
-		      uint8_t event_type)
+		      enum adf_proto_dir dir)
 {
 	enum adf_proto_subtype subtype = ADF_PROTO_INVALID;
 
@@ -446,9 +474,12 @@ bool adf_log_dhcp_pkt(uint8_t session_id, struct sk_buff *skb,
 			session_id, (skb->data + ADF_NBUF_SRC_MAC_OFFSET),
 			(skb->data + ADF_NBUF_DEST_MAC_OFFSET),
 			ADF_PROTO_TYPE_DHCP, subtype,
-			event_type == ADF_RX ?
-			ADF_RX : ADF_TX));
-		ADF_NBUF_SET_DP_TRACE(skb, 1);
+			dir));
+		if (ADF_TX == dir)
+			ADF_NBUF_CB_TX_DP_TRACE(skb) = 1;
+		else if (ADF_RX == dir)
+			ADF_NBUF_CB_RX_DP_TRACE(skb) = 1;
+
 		return true;
 	}
 	return false;
@@ -458,12 +489,12 @@ bool adf_log_dhcp_pkt(uint8_t session_id, struct sk_buff *skb,
  * adf_log_arp_pkt() - log ARP packet
  * @session_id: vdev_id
  * @skb: skb pointer
- * @event_type: event_type
+ * @dir: direction
  *
  * Return: true/false
  */
 bool adf_log_arp_pkt(uint8_t session_id, struct sk_buff *skb,
-		     uint8_t event_type)
+		     enum adf_proto_dir dir)
 {
 	enum adf_proto_subtype proto_subtype;
 
@@ -476,9 +507,12 @@ bool adf_log_arp_pkt(uint8_t session_id, struct sk_buff *skb,
 			session_id, (skb->data + ADF_NBUF_SRC_MAC_OFFSET),
 			(skb->data + ADF_NBUF_DEST_MAC_OFFSET),
 			ADF_PROTO_TYPE_ARP, proto_subtype,
-			event_type == ADF_RX ?
-			ADF_RX : ADF_TX));
-		ADF_NBUF_SET_DP_TRACE(skb, 1);
+			dir));
+		if (ADF_TX == dir)
+			ADF_NBUF_CB_TX_DP_TRACE(skb) = 1;
+		else if (ADF_RX == dir)
+			ADF_NBUF_CB_RX_DP_TRACE(skb) = 1;
+
 		return true;
 	}
 	return false;
@@ -488,20 +522,20 @@ bool adf_log_arp_pkt(uint8_t session_id, struct sk_buff *skb,
  * adf_dp_trace_log_pkt() - log packet type enabled through iwpriv
  * @session_id: vdev_id
  * @skb: skb pointer
- * @event_type: event type
+ * @dir: direction
  *
  * Return: none
  */
 void adf_dp_trace_log_pkt(uint8_t session_id, struct sk_buff *skb,
-			  uint8_t event_type)
+			  enum adf_proto_dir dir)
 {
 	if (adf_dp_get_proto_bitmap()) {
 		if (adf_log_arp_pkt(session_id,
-			skb, event_type) == false) {
+			skb, dir) == false) {
 			if (adf_log_dhcp_pkt(session_id,
-				skb, event_type) == false) {
+				skb, dir) == false) {
 				if (adf_log_eapol_pkt(session_id,
-					skb, event_type) == false) {
+					skb, dir) == false) {
 					return;
 				}
 			}
@@ -522,10 +556,10 @@ void adf_dp_display_proto_pkt(struct adf_dp_trace_record_s *record,
 	struct adf_dp_trace_proto_buf *buf =
 		(struct adf_dp_trace_proto_buf *)record->data;
 
-	adf_os_print("%04d: %012llu: %s vdev_id %d\n", index,
+	adf_os_print("DPT: %04d: %012llu: %s vdev_id %d\n", index,
 		record->time, adf_dp_code_to_string(record->code),
 		buf->vdev_id);
-	adf_os_print("SA: " MAC_ADDRESS_STR " %s DA: " MAC_ADDRESS_STR
+	adf_os_print("DPT: SA: " MAC_ADDRESS_STR " %s DA: " MAC_ADDRESS_STR
 						" Type %s Subtype %s\n",
 		MAC_ADDR_ARRAY(buf->sa.bytes), adf_dp_dir_to_str(buf->dir),
 		MAC_ADDR_ARRAY(buf->da.bytes), adf_dp_type_to_str(buf->type),
@@ -551,7 +585,7 @@ void adf_dp_trace_proto_pkt(enum ADF_DP_TRACE_ID code, uint8_t vdev_id,
 	struct adf_dp_trace_proto_buf buf;
 	int buf_size = sizeof(struct adf_dp_trace_ptr_buf);
 
-	if (adf_dp_enable_check(NULL, code) == false)
+	if (adf_dp_enable_check(NULL, code, dir) == false)
 		return;
 
 	if (buf_size > ADF_DP_TRACE_RECORD_SIZE)
@@ -563,7 +597,7 @@ void adf_dp_trace_proto_pkt(enum ADF_DP_TRACE_ID code, uint8_t vdev_id,
 	buf.type = type;
 	buf.subtype = subtype;
 	buf.vdev_id = vdev_id;
-	adf_dp_add_record(code, (uint8_t *)&buf, buf_size);
+	adf_dp_add_record(code, (uint8_t *)&buf, buf_size, true);
 }
 
 /**
@@ -579,9 +613,15 @@ void adf_dp_display_ptr_record(struct adf_dp_trace_record_s *record,
 	struct adf_dp_trace_ptr_buf *buf =
 		(struct adf_dp_trace_ptr_buf *)record->data;
 
-	adf_os_print("%04d: %012llu: %s msdu_id: %d, status: %d", index,
-		record->time, adf_dp_code_to_string(record->code),
-		buf->msdu_id, buf->status);
+	if (record->code == ADF_DP_TRACE_FREE_PACKET_PTR_RECORD)
+		adf_os_print("%04d: %012llu: %s msdu_id: %d, status: %d\n", index,
+			record->time, adf_dp_code_to_string(record->code),
+			buf->msdu_id, buf->status);
+	else
+		adf_os_print("%04d: %012llu: %s msdu_id: %d, vdev_id: %d\n", index,
+			record->time, adf_dp_code_to_string(record->code),
+			buf->msdu_id, buf->status);
+
 	dump_hex_trace("cookie", (uint8_t *)&buf->cookie, sizeof(buf->cookie));
 }
 
@@ -601,7 +641,7 @@ void adf_dp_trace_ptr(adf_nbuf_t nbuf, enum ADF_DP_TRACE_ID code,
 	struct adf_dp_trace_ptr_buf buf;
 	int buf_size = sizeof(struct adf_dp_trace_ptr_buf);
 
-	if (adf_dp_enable_check(nbuf, code) == false)
+	if (adf_dp_enable_check(nbuf, code, ADF_TX) == false)
 		return;
 
 	if (buf_size > ADF_DP_TRACE_RECORD_SIZE)
@@ -610,7 +650,7 @@ void adf_dp_trace_ptr(adf_nbuf_t nbuf, enum ADF_DP_TRACE_ID code,
 	adf_os_mem_copy(&buf.cookie, data, size);
 	buf.msdu_id = msdu_id;
 	buf.status = status;
-	adf_dp_add_record(code, (uint8_t *)&buf, buf_size);
+	adf_dp_add_record(code, (uint8_t *)&buf, buf_size, false);
 }
 
 /**
@@ -623,7 +663,7 @@ void adf_dp_trace_ptr(adf_nbuf_t nbuf, enum ADF_DP_TRACE_ID code,
 void adf_dp_display_record(struct adf_dp_trace_record_s *pRecord,
 				uint16_t recIndex)
 {
-	adf_os_print("%04d: %012llu: %s", recIndex,
+	adf_os_print("DPT: %04d: %012llu: %s\n", recIndex,
 		pRecord->time, adf_dp_code_to_string(pRecord->code));
 	switch (pRecord->code) {
 	case  ADF_DP_TRACE_HDD_TX_TIMEOUT:
@@ -634,7 +674,7 @@ void adf_dp_display_record(struct adf_dp_trace_record_s *pRecord,
 		VOS_TRACE(VOS_MODULE_ID_ADF, VOS_TRACE_LEVEL_ERROR,
 						"HDD SoftAP TX Timeout\n");
 		break;
-	case ADF_DP_TRACE_HDD_PACKET_RECORD:
+	case ADF_DP_TRACE_HDD_TX_PACKET_RECORD:
 		dump_hex_trace("DATA", pRecord->data, pRecord->size);
 		break;
 	default:
@@ -652,12 +692,38 @@ void adf_dp_display_record(struct adf_dp_trace_record_s *pRecord,
  * Return: None
  */
 void adf_dp_trace(adf_nbuf_t nbuf, enum ADF_DP_TRACE_ID code,
-			uint8_t *data, uint8_t size)
+			uint8_t *data, uint8_t size, enum adf_proto_dir dir)
 {
-	if (adf_dp_enable_check(nbuf, code) == false)
+
+	if (adf_dp_enable_check(nbuf, code, dir) == false)
 		return;
 
-	adf_dp_add_record(code, data, size);
+	adf_dp_add_record(code, data, size, false);
+}
+
+/**
+ * adf_dp_trace_enable_live_mode() - enable live mode
+ *
+ * Return: none
+ */
+void adf_dp_trace_enable_live_mode(void)
+{
+	g_adf_dp_trace_data.live_mode = 1;
+}
+
+void adf_dp_trace_clear_buffer(void)
+{
+	g_adf_dp_trace_data.head = INVALID_ADF_DP_TRACE_ADDR;
+	g_adf_dp_trace_data.tail = INVALID_ADF_DP_TRACE_ADDR;
+	g_adf_dp_trace_data.num = 0;
+	g_adf_dp_trace_data.proto_bitmap = 0;
+	g_adf_dp_trace_data.no_of_record = 0;
+	g_adf_dp_trace_data.verbosity	 = ADF_DP_TRACE_VERBOSITY_DEFAULT;
+	g_adf_dp_trace_data.enable = true;
+
+	memset(g_adf_dp_trace_tbl, 0,
+		MAX_ADF_DP_TRACE_RECORDS * sizeof(struct adf_dp_trace_record_s));
+
 }
 
 /**
diff --git a/CORE/SERVICES/COMMON/adf/adf_trace.h b/CORE/SERVICES/COMMON/adf/adf_trace.h
index b426edd26ae2..e01cfbc17f7c 100644
--- a/CORE/SERVICES/COMMON/adf/adf_trace.h
+++ b/CORE/SERVICES/COMMON/adf/adf_trace.h
@@ -56,6 +56,11 @@
 #define ADF_DP_TRACE_VERBOSITY_LOW     1
 #define ADF_DP_TRACE_VERBOSITY_DEFAULT 0
 
+#define DUMP_DP_TRACE       0
+#define ENABLE_DP_TRACE_LIVE_MODE	1
+#define CLEAR_DP_TRACE_BUFFER	2
+
+
 /**
  * struct adf_mac_addr - mac address array
  * @bytes: MAC address bytes
@@ -68,8 +73,8 @@ struct adf_mac_addr {
  * enum ADF_DP_TRACE_ID - Generic ID to identify various events in data path
  * @ADF_DP_TRACE_INVALID: Invalid ID
  * @ADF_DP_TRACE_DROP_PACKET_RECORD: Dropped packet stored with this id
- * @ADF_DP_TRACE_HDD_PACKET_PTR_RECORD: nbuf->data ptr of HDD
- * @ADF_DP_TRACE_HDD_PACKET_RECORD: nbuf->data stored with this id
+ * @ADF_DP_TRACE_HDD_TX_PACKET_PTR_RECORD: nbuf->data ptr of HDD
+ * @ADF_DP_TRACE_HDD_TX_PACKET_RECORD: nbuf->data stored with this id
  * @ADF_DP_TRACE_CE_PACKET_PTR_RECORD: nbuf->data ptr of CE
  * @ADF_DP_TRACE_CE_PACKET_RECORD: nbuf->data stored with this id
  * @ADF_DP_TRACE_TXRX_QUEUE_PACKET_PTR_RECORD: nbuf->data ptr of txrx queue
@@ -91,10 +96,13 @@ enum  ADF_DP_TRACE_ID {
 	ADF_DP_TRACE_DEFAULT_VERBOSITY,
 	ADF_DP_TRACE_HDD_TX_TIMEOUT,
 	ADF_DP_TRACE_HDD_SOFTAP_TX_TIMEOUT,
-	ADF_DP_TRACE_HDD_PACKET_PTR_RECORD,
+	ADF_DP_TRACE_HDD_TX_PACKET_PTR_RECORD,
 	ADF_DP_TRACE_CE_PACKET_PTR_RECORD,
 	ADF_DP_TRACE_CE_FAST_PACKET_PTR_RECORD,
 	ADF_DP_TRACE_FREE_PACKET_PTR_RECORD,
+	ADF_DP_TRACE_RX_HTT_PACKET_PTR_RECORD,
+	ADF_DP_TRACE_RX_OFFLOAD_HTT_PACKET_PTR_RECORD,
+	ADF_DP_TRACE_RX_HDD_PACKET_PTR_RECORD,
 	ADF_DP_TRACE_LOW_VERBOSITY,
 	ADF_DP_TRACE_TXRX_QUEUE_PACKET_PTR_RECORD,
 	ADF_DP_TRACE_TXRX_PACKET_PTR_RECORD,
@@ -102,8 +110,9 @@ enum  ADF_DP_TRACE_ID {
 	ADF_DP_TRACE_HTT_PACKET_PTR_RECORD,
 	ADF_DP_TRACE_HTC_PACKET_PTR_RECORD,
 	ADF_DP_TRACE_HIF_PACKET_PTR_RECORD,
+	ADF_DP_TRACE_RX_TXRX_PACKET_PTR_RECORD,
 	ADF_DP_TRACE_MED_VERBOSITY,
-	ADF_DP_TRACE_HDD_PACKET_RECORD,
+	ADF_DP_TRACE_HDD_TX_PACKET_RECORD,
 	ADF_DP_TRACE_HIGH_VERBOSITY,
 	ADF_DP_TRACE_MAX
 };
@@ -166,7 +175,9 @@ struct s_adf_dp_trace_data {
 	uint8_t no_of_record;
 	uint8_t verbosity;
 	bool enable;
-	uint32_t count;
+	uint32_t tx_count;
+	uint32_t rx_count;
+	bool live_mode;
 };
 /* Function declarations and documenation */
 
@@ -174,9 +185,9 @@ struct s_adf_dp_trace_data {
 void adf_dp_trace_init(void);
 void adf_dp_trace_set_value(uint8_t proto_bitmap, uint8_t no_of_records,
 			 uint8_t verbosity);
-void adf_dp_trace_set_track(adf_nbuf_t nbuf);
+void adf_dp_trace_set_track(adf_nbuf_t nbuf, enum adf_proto_dir dir);
 void adf_dp_trace(adf_nbuf_t nbuf, enum ADF_DP_TRACE_ID code,
-			uint8_t *data, uint8_t size);
+			uint8_t *data, uint8_t size, enum adf_proto_dir dir);
 void adf_dp_trace_dump_all(uint32_t count);
 typedef void (*tp_adf_dp_trace_cb)(struct adf_dp_trace_record_s* , uint16_t);
 void adf_dp_display_record(struct adf_dp_trace_record_s *record,
@@ -194,7 +205,9 @@ adf_dp_trace_proto_pkt(enum ADF_DP_TRACE_ID code, uint8_t vdev_id,
 void adf_dp_display_proto_pkt(struct adf_dp_trace_record_s *record,
 				uint16_t index);
 void adf_dp_trace_log_pkt(uint8_t session_id, struct sk_buff *skb,
-				uint8_t event_type);
+				enum adf_proto_dir dir);
+void adf_dp_trace_enable_live_mode(void);
+void adf_dp_trace_clear_buffer(void);
 
 #else
 static inline void adf_dp_trace_init(void)
@@ -206,12 +219,14 @@ static inline void adf_dp_trace_set_value(uint8_t proto_bitmap,
 {
 }
 
-static inline void adf_dp_trace_set_track(adf_nbuf_t nbuf)
+static inline void adf_dp_trace_set_track(adf_nbuf_t nbuf,
+	enum adf_proto_dir dir)
 {
 }
 
 static inline void adf_dp_trace(adf_nbuf_t nbuf,
-		enum ADF_DP_TRACE_ID code, uint8_t *data, uint8_t size)
+		enum ADF_DP_TRACE_ID code, uint8_t *data, uint8_t size,
+		enum adf_proto_dir dir)
 {
 }
 
@@ -254,10 +269,19 @@ adf_dp_display_proto_pkt(struct adf_dp_trace_record_s *record,
 }
 
 static inline void adf_dp_trace_log_pkt(uint8_t session_id, struct sk_buff *skb,
-				uint8_t event_type)
+				enum adf_proto_dir dir)
 {
 }
 
+static inline
+void adf_dp_trace_enable_live_mode(void)
+{
+}
+
+static inline
+void adf_dp_trace_clear_buffer(void)
+{
+}
 #endif
 
 #endif  /* __ADF_TRACE_H */
diff --git a/CORE/SERVICES/COMMON/adf/linux/adf_nbuf_pvt.h b/CORE/SERVICES/COMMON/adf/linux/adf_nbuf_pvt.h
index 431d2c4d7f2c..70fd459f891b 100644
--- a/CORE/SERVICES/COMMON/adf/linux/adf_nbuf_pvt.h
+++ b/CORE/SERVICES/COMMON/adf/linux/adf_nbuf_pvt.h
@@ -65,6 +65,17 @@ typedef void (*__adf_nbuf_callback_fn) (struct sk_buff *skb);
 #define CVG_NBUF_MAX_EXTRA_FRAGS 2
 
 typedef void (*adf_nbuf_trace_update_t)(char *);
+struct nbuf_rx_cb {
+	uint8_t dp_trace:1,
+		    reserved:7;
+	uint8_t packet_trace;
+};
+
+#define ADF_NBUF_CB_RX_DP_TRACE(skb) \
+	(((struct nbuf_rx_cb*)((skb)->cb))->dp_trace)
+
+#define ADF_NBUF_CB_RX_PACKET_TRACE(skb) \
+	(((struct nbuf_rx_cb*)((skb)->cb))->packet_trace)
 
 struct cvg_nbuf_cb {
     /*
@@ -219,10 +230,7 @@ struct cvg_nbuf_cb {
 #define NBUF_UPDATE_TX_PKT_COUNT(skb, PACKET_STATE) \
     adf_nbuf_set_state(skb, PACKET_STATE)
 
-#define ADF_NBUF_SET_DP_TRACE(skb, enable) \
-    (((struct cvg_nbuf_cb *)((skb)->cb))->trace.dp_trace \
-                                     = enable)
-#define ADF_NBUF_GET_DP_TRACE(skb) \
+#define ADF_NBUF_CB_TX_DP_TRACE(skb) \
     (((struct cvg_nbuf_cb *)((skb)->cb))->trace.dp_trace)
 
 #define __adf_nbuf_get_num_frags(skb)              \
diff --git a/CORE/SERVICES/HIF/PCIe/copy_engine.c b/CORE/SERVICES/HIF/PCIe/copy_engine.c
index 7ade81b38786..c2047c2af24b 100644
--- a/CORE/SERVICES/HIF/PCIe/copy_engine.c
+++ b/CORE/SERVICES/HIF/PCIe/copy_engine.c
@@ -428,7 +428,7 @@ CE_sendlist_send(struct CE_handle *copyeng,
         DPTRACE(adf_dp_trace((adf_nbuf_t)per_transfer_context,
                 ADF_DP_TRACE_CE_PACKET_PTR_RECORD,
                (uint8_t *)&(((adf_nbuf_t)per_transfer_context)->data),
-               sizeof(((adf_nbuf_t)per_transfer_context)->data)));
+               sizeof(((adf_nbuf_t)per_transfer_context)->data), ADF_TX));
     } else {
         /*
          * Probably not worth the additional complexity to support
diff --git a/CORE/SERVICES/HIF/PCIe/hif_pci.c b/CORE/SERVICES/HIF/PCIe/hif_pci.c
index 3a1de9d23d07..26c73b5928f9 100644
--- a/CORE/SERVICES/HIF/PCIe/hif_pci.c
+++ b/CORE/SERVICES/HIF/PCIe/hif_pci.c
@@ -375,7 +375,7 @@ HIFSend_head(HIF_DEVICE *hif_device,
     NBUF_UPDATE_TX_PKT_COUNT(nbuf, NBUF_TX_PKT_HIF);
     DPTRACE(adf_dp_trace(nbuf, ADF_DP_TRACE_HIF_PACKET_PTR_RECORD,
                 adf_nbuf_data_addr(nbuf),
-                sizeof(adf_nbuf_data(nbuf))));
+                sizeof(adf_nbuf_data(nbuf)), ADF_TX));
     status = CE_sendlist_send(ce_hdl, nbuf, &sendlist, transfer_id);
     A_ASSERT(status == A_OK);
 
diff --git a/CORE/SERVICES/HTC/htc_send.c b/CORE/SERVICES/HTC/htc_send.c
index ec70a40fed00..c67f17366c4d 100644
--- a/CORE/SERVICES/HTC/htc_send.c
+++ b/CORE/SERVICES/HTC/htc_send.c
@@ -1331,7 +1331,7 @@ A_STATUS HTCSendDataPkt(HTC_HANDLE HTCHandle, adf_nbuf_t       netbuf, int Epid,
     NBUF_UPDATE_TX_PKT_COUNT(netbuf, NBUF_TX_PKT_HTC);
     DPTRACE(adf_dp_trace(netbuf, ADF_DP_TRACE_HTC_PACKET_PTR_RECORD,
                 adf_nbuf_data_addr(netbuf),
-                sizeof(adf_nbuf_data(netbuf))));
+                sizeof(adf_nbuf_data(netbuf)), ADF_TX));
 
     status = HIFSend_head(target->hif_dev,
             pEndpoint->UL_PipeID,