qcacld-3.0: Enhance data path related statistics

Enhance data path related statistics
- Add per reason pause time
- Enahnce TSO stats
- clear DPTRACE buffer

Change-Id: Ia59fa5ba326504eb54e14d44f42a335c6b835ee4
CRs-Fixed: 1017437

core/dp/htt/htt_rx.c

@@ -1940,7 +1940,7 @@ htt_rx_amsdu_rx_in_order_pop_ll(htt_pdev_handle pdev,
 	uint8_t *rx_ind_data;
 	uint32_t *msg_word;
 	unsigned int msdu_count = 0;
-	uint8_t offload_ind;
+	uint8_t offload_ind, frag_ind;
 	struct htt_host_rx_desc_base *rx_desc;
 	uint8_t peer_id;
 
@@ -1952,11 +1952,12 @@ htt_rx_amsdu_rx_in_order_pop_ll(htt_pdev_handle pdev,
 					*(u_int32_t *)rx_ind_data);
 
 	offload_ind = HTT_RX_IN_ORD_PADDR_IND_OFFLOAD_GET(*msg_word);
+	frag_ind = HTT_RX_IN_ORD_PADDR_IND_FRAG_GET(*msg_word);
 
 	/* 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);
-	ol_rx_update_histogram_stats(msdu_count);
+	ol_rx_update_histogram_stats(msdu_count, frag_ind, offload_ind);
 
 	msg_word =
 		(uint32_t *) (rx_ind_data + HTT_RX_IN_ORD_PADDR_IND_HDR_BYTES);

core/dp/ol/inc/ol_txrx_stats.h

@@ -53,6 +53,9 @@ struct ol_txrx_stats_tso_msdu {
 	struct qdf_tso_seg_t tso_segs[NUM_MAX_TSO_SEGS];
 	uint8_t num_seg;
 	uint8_t tso_seg_idx;
+	uint32_t total_len;
+	uint32_t gso_size;
+	uint8_t nr_frags;
 };
 
 struct ol_txrx_stats_tso_info {
@@ -81,6 +84,15 @@ struct ol_txrx_stats_tx_dropped {
 	struct ol_txrx_stats_elem no_ack;
 };
 
+struct ol_txrx_tso_histogram {
+	uint32_t pkts_1;
+	uint32_t pkts_2_5;
+	uint32_t pkts_6_10;
+	uint32_t pkts_11_15;
+	uint32_t pkts_16_20;
+	uint32_t pkts_20_plus;
+};
+
 struct ol_txrx_stats_tx_histogram {
 	uint32_t pkts_1;
 	uint32_t pkts_2_10;
@@ -95,12 +107,15 @@ struct ol_txrx_stats_tx_tso {
 	struct ol_txrx_stats_elem tso_pkts;
 #if defined(FEATURE_TSO)
 	struct ol_txrx_stats_tso_info tso_info;
+	struct ol_txrx_tso_histogram tso_hist;
 #endif
 };
 
 struct ol_txrx_stats_tx {
 	/* MSDUs given to the txrx layer by the management stack */
 	struct ol_txrx_stats_elem mgmt;
+	/* MSDUs received from the stack */
+	struct ol_txrx_stats_elem from_stack;
 	/* MSDUs successfully sent across the WLAN */
 	struct ol_txrx_stats_elem delivered;
 	struct ol_txrx_stats_tx_dropped dropped;
@@ -139,6 +154,8 @@ struct ol_txrx_stats_rx {
 	struct ol_txrx_stats_elem dropped_peer_invalid;
 	struct ol_txrx_stats_rx_ibss_fwd intra_bss_fwd;
 	struct ol_txrx_stats_rx_histogram rx_ind_histogram;
+	uint32_t msdus_with_frag_ind;
+	uint32_t msdus_with_offload_ind;
 };
 struct ol_txrx_stats {
 	struct ol_txrx_stats_tx tx;

core/dp/txrx/ol_rx.c

@@ -104,10 +104,13 @@ void ol_rx_trigger_restore(htt_pdev_handle htt_pdev, qdf_nbuf_t head_msdu,
 /**
  * ol_rx_update_histogram_stats() - update rx histogram statistics
  * @msdu_count: msdu count
+ * @frag_ind: fragment indication set
+ * @offload_ind: offload indication set
  *
  * Return: none
  */
-void ol_rx_update_histogram_stats(uint32_t msdu_count)
+void ol_rx_update_histogram_stats(uint32_t msdu_count, uint8_t frag_ind,
+		 uint8_t offload_ind)
 {
 	struct ol_txrx_pdev_t *pdev = cds_get_context(QDF_MODULE_ID_TXRX);
 
@@ -134,6 +137,13 @@ void ol_rx_update_histogram_stats(uint32_t msdu_count)
 	} else if (msdu_count == 1) {
 		TXRX_STATS_ADD(pdev, pub.rx.rx_ind_histogram.pkts_1, 1);
 	}
+
+	if (frag_ind)
+		TXRX_STATS_ADD(pdev, pub.rx.msdus_with_frag_ind, msdu_count);
+
+	if (offload_ind)
+		TXRX_STATS_ADD(pdev, pub.rx.msdus_with_offload_ind, msdu_count);
+
 }
 
 static void ol_rx_process_inv_peer(ol_txrx_pdev_handle pdev,

core/dp/txrx/ol_rx.h

@@ -58,7 +58,8 @@ void
 ol_rx_offload_paddr_deliver_ind_handler(htt_pdev_handle htt_pdev,
 					uint32_t msdu_count,
 					uint32_t *msg_word);
-void ol_rx_update_histogram_stats(uint32_t msdu_count);
+void ol_rx_update_histogram_stats(uint32_t msdu_count,
+		uint8_t frag_ind, uint8_t offload_ind);
 
 void
 ol_rx_mic_error_handler(

core/dp/txrx/ol_tx.c

@@ -247,6 +247,14 @@ qdf_nbuf_t ol_tx_ll(ol_txrx_vdev_handle vdev, qdf_nbuf_t msdu_list)
 		}
 
 		segments = msdu_info.tso_info.num_segs;
+		TXRX_STATS_TSO_HISTOGRAM(vdev->pdev, segments);
+		TXRX_STATS_TSO_GSO_SIZE_UPDATE(vdev->pdev,
+					 qdf_nbuf_tcp_tso_size(msdu));
+		TXRX_STATS_TSO_TOTAL_LEN_UPDATE(vdev->pdev,
+					 qdf_nbuf_len(msdu));
+		TXRX_STATS_TSO_NUM_FRAGS_UPDATE(vdev->pdev,
+					 qdf_nbuf_get_nr_frags(msdu));
+
 
 		/*
 		 * The netbuf may get linked into a different list inside the
@@ -275,6 +283,8 @@ qdf_nbuf_t ol_tx_ll(ol_txrx_vdev_handle vdev, qdf_nbuf_t msdu_list)
 
 			ol_tx_prepare_ll(tx_desc, vdev, msdu, &msdu_info);
 
+			TXRX_STATS_MSDU_INCR(vdev->pdev, tx.from_stack, msdu);
+
 			/*
 			 * If debug display is enabled, show the meta-data being
 			 * downloaded to the target via the HTT tx descriptor.
@@ -328,6 +338,8 @@ qdf_nbuf_t ol_tx_ll(ol_txrx_vdev_handle vdev, qdf_nbuf_t msdu_list)
 		msdu_info.peer = NULL;
 		ol_tx_prepare_ll(tx_desc, vdev, msdu, &msdu_info);
 
+		TXRX_STATS_MSDU_INCR(vdev->pdev, tx.from_stack, msdu);
+
 		/*
 		 * If debug display is enabled, show the meta-data being
 		 * downloaded to the target via the HTT tx descriptor.
@@ -531,6 +543,13 @@ ol_tx_ll_fast(ol_txrx_vdev_handle vdev, qdf_nbuf_t msdu_list)
 		}
 
 		segments = msdu_info.tso_info.num_segs;
+		TXRX_STATS_TSO_HISTOGRAM(vdev->pdev, segments);
+		TXRX_STATS_TSO_GSO_SIZE_UPDATE(vdev->pdev,
+				 qdf_nbuf_tcp_tso_size(msdu));
+		TXRX_STATS_TSO_TOTAL_LEN_UPDATE(vdev->pdev,
+				 qdf_nbuf_len(msdu));
+		TXRX_STATS_TSO_NUM_FRAGS_UPDATE(vdev->pdev,
+				 qdf_nbuf_get_nr_frags(msdu));
 
 		/*
 		 * The netbuf may get linked into a different list
@@ -580,6 +599,8 @@ ol_tx_ll_fast(ol_txrx_vdev_handle vdev, qdf_nbuf_t msdu_list)
 						  pkt_download_len, ep_id,
 						  &msdu_info);
 
+			TXRX_STATS_MSDU_INCR(pdev, tx.from_stack, msdu);
+
 			if (qdf_likely(tx_desc)) {
 				DPTRACE(qdf_dp_trace_ptr(msdu,
 				    QDF_DP_TRACE_TXRX_FAST_PACKET_PTR_RECORD,
@@ -684,6 +705,8 @@ ol_tx_ll_fast(ol_txrx_vdev_handle vdev, qdf_nbuf_t msdu_list)
 					  pkt_download_len, ep_id,
 					  &msdu_info);
 
+		TXRX_STATS_MSDU_INCR(pdev, tx.from_stack, msdu);
+
 		if (qdf_likely(tx_desc)) {
 			DPTRACE(qdf_dp_trace_ptr(msdu,
 				QDF_DP_TRACE_TXRX_FAST_PACKET_PTR_RECORD,

core/dp/txrx/ol_tx_desc.c

@@ -236,8 +236,8 @@ struct ol_tx_desc_t *ol_tx_desc_alloc(struct ol_txrx_pdev_t *pdev,
 			ol_tx_desc_sanity_checks(pdev, tx_desc);
 			ol_tx_desc_compute_delay(tx_desc);
 		} else {
+			pool->pkt_drop_no_desc++;
 			qdf_spin_unlock_bh(&pool->flow_pool_lock);
-			pdev->pool_stats.pkt_drop_no_desc++;
 		}
 	} else {
 		pdev->pool_stats.pkt_drop_no_pool++;

core/dp/txrx/ol_txrx.c

@@ -3520,17 +3520,42 @@ void ol_txrx_stats_display_tso(ol_txrx_pdev_handle pdev)
 	int msdu_idx;
 	int seg_idx;
 
+	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+		"TSO Statistics:");
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
 		"TSO pkts %lld, bytes %lld\n",
 		pdev->stats.pub.tx.tso.tso_pkts.pkts,
 		pdev->stats.pub.tx.tso.tso_pkts.bytes);
 
+	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+			"TSO Histogram for numbers of segments:\n"
+			"Single segment	%d\n"
+			"  2-5 segments	%d\n"
+			" 6-10 segments	%d\n"
+			"11-15 segments	%d\n"
+			"16-20 segments	%d\n"
+			"  20+ segments	%d\n",
+			pdev->stats.pub.tx.tso.tso_hist.pkts_1,
+			pdev->stats.pub.tx.tso.tso_hist.pkts_2_5,
+			pdev->stats.pub.tx.tso.tso_hist.pkts_6_10,
+			pdev->stats.pub.tx.tso.tso_hist.pkts_11_15,
+			pdev->stats.pub.tx.tso.tso_hist.pkts_16_20,
+			pdev->stats.pub.tx.tso.tso_hist.pkts_20_plus);
+
+	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+			"TSO History Buffer: Total size %d, current_index %d",
+			NUM_MAX_TSO_MSDUS,
+			TXRX_STATS_TSO_MSDU_IDX(pdev));
+
 	for (msdu_idx = 0; msdu_idx < NUM_MAX_TSO_MSDUS; msdu_idx++) {
 		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
-			"curr msdu idx: %d curr seg idx: %d num segs %d\n",
-			TXRX_STATS_TSO_MSDU_IDX(pdev),
-			TXRX_STATS_TSO_SEG_IDX(pdev),
-			TXRX_STATS_TSO_MSDU_NUM_SEG(pdev, msdu_idx));
+			"jumbo pkt idx: %d num segs %d gso_len %d total_len %d nr_frags %d",
+			msdu_idx,
+			TXRX_STATS_TSO_MSDU_NUM_SEG(pdev, msdu_idx),
+			TXRX_STATS_TSO_MSDU_GSO_SIZE(pdev, msdu_idx),
+			TXRX_STATS_TSO_MSDU_TOTAL_LEN(pdev, msdu_idx),
+			TXRX_STATS_TSO_MSDU_NR_FRAGS(pdev, msdu_idx));
+
 		for (seg_idx = 0;
 			 ((seg_idx < TXRX_STATS_TSO_MSDU_NUM_SEG(pdev, msdu_idx)) &&
 			  (seg_idx < NUM_MAX_TSO_SEGS));
@@ -3539,24 +3564,23 @@ void ol_txrx_stats_display_tso(ol_txrx_pdev_handle pdev)
 				 TXRX_STATS_TSO_SEG(pdev, msdu_idx, seg_idx);
 
 			QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
-				 "msdu idx: %d seg idx: %d\n",
-				 msdu_idx, seg_idx);
+				 "seg idx: %d", seg_idx);
 			QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
-				 "tso_enable: %d\n",
+				 "tso_enable: %d",
 				 tso_seg.tso_flags.tso_enable);
 			QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
-				 "fin %d syn %d rst %d psh %d ack %d\n"
-				 "urg %d ece %d cwr %d ns %d\n",
+				 "fin %d syn %d rst %d psh %d ack %d urg %d ece %d cwr %d ns %d",
 				 tso_seg.tso_flags.fin, tso_seg.tso_flags.syn,
 				 tso_seg.tso_flags.rst, tso_seg.tso_flags.psh,
 				 tso_seg.tso_flags.ack, tso_seg.tso_flags.urg,
 				 tso_seg.tso_flags.ece, tso_seg.tso_flags.cwr,
 				 tso_seg.tso_flags.ns);
 			QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
-				 "tcp_seq_num: 0x%x ip_id: %d\n",
+				 "tcp_seq_num: 0x%x ip_id: %d",
 				 tso_seg.tso_flags.tcp_seq_num,
 				 tso_seg.tso_flags.ip_id);
 		}
+	 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, "\n");
 	}
 }
 #else
@@ -3605,9 +3629,9 @@ void ol_txrx_stats_display(ol_txrx_pdev_handle pdev)
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
 		  "TX PATH Statistics:");
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
-		  "sent %lld msdus (%lld B), rejected %lld (%lld B), dropped %lld (%lld B)",
-		  pdev->stats.pub.tx.delivered.pkts,
-		  pdev->stats.pub.tx.delivered.bytes,
+		  "sent %lld msdus (%lld B), host rejected %lld (%lld B), dropped %lld (%lld B)",
+		  pdev->stats.pub.tx.from_stack.pkts,
+		  pdev->stats.pub.tx.from_stack.bytes,
 		  pdev->stats.pub.tx.dropped.host_reject.pkts,
 		  pdev->stats.pub.tx.dropped.host_reject.bytes,
 		  pdev->stats.pub.tx.dropped.download_fail.pkts
@@ -3617,9 +3641,12 @@ void ol_txrx_stats_display(ol_txrx_pdev_handle pdev)
 		  + pdev->stats.pub.tx.dropped.target_discard.bytes
 		  + pdev->stats.pub.tx.dropped.no_ack.bytes);
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
-		  "    download fail: %lld (%lld B), "
+		  "successfully delivered: %lld (%lld B), "
+		  "download fail: %lld (%lld B), "
 		  "target discard: %lld (%lld B), "
 		  "no ack: %lld (%lld B)",
+		  pdev->stats.pub.tx.delivered.pkts,
+		  pdev->stats.pub.tx.delivered.bytes,
 		  pdev->stats.pub.tx.dropped.download_fail.pkts,
 		  pdev->stats.pub.tx.dropped.download_fail.bytes,
 		  pdev->stats.pub.tx.dropped.target_discard.pkts,
@@ -3627,7 +3654,7 @@ void ol_txrx_stats_display(ol_txrx_pdev_handle pdev)
 		  pdev->stats.pub.tx.dropped.no_ack.pkts,
 		  pdev->stats.pub.tx.dropped.no_ack.bytes);
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
-		  "Tx completion per interrupt:\n"
+		  "Tx completions per HTT message:\n"
 		  "Single Packet  %d\n"
 		  " 2-10 Packets  %d\n"
 		  "11-20 Packets  %d\n"
@@ -3644,11 +3671,13 @@ void ol_txrx_stats_display(ol_txrx_pdev_handle pdev)
 		  pdev->stats.pub.tx.comp_histogram.pkts_41_50,
 		  pdev->stats.pub.tx.comp_histogram.pkts_51_60,
 		  pdev->stats.pub.tx.comp_histogram.pkts_61_plus);
+
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
 		  "RX PATH Statistics:");
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
 		  "%lld ppdus, %lld mpdus, %lld msdus, %lld bytes\n"
-		  "dropped: err %lld (%lld B), peer_invalid %lld (%lld B), mic_err %lld (%lld B)",
+		  "dropped: err %lld (%lld B), peer_invalid %lld (%lld B), mic_err %lld (%lld B)\n"
+		  "msdus with frag_ind: %d msdus with offload_ind: %d",
 		  pdev->stats.priv.rx.normal.ppdus,
 		  pdev->stats.priv.rx.normal.mpdus,
 		  pdev->stats.pub.rx.delivered.pkts,
@@ -3658,8 +3687,9 @@ void ol_txrx_stats_display(ol_txrx_pdev_handle pdev)
 		  pdev->stats.pub.rx.dropped_peer_invalid.pkts,
 		  pdev->stats.pub.rx.dropped_peer_invalid.bytes,
 		  pdev->stats.pub.rx.dropped_mic_err.pkts,
-		  pdev->stats.pub.rx.dropped_mic_err.bytes);
-
+		  pdev->stats.pub.rx.dropped_mic_err.bytes,
+		  pdev->stats.pub.rx.msdus_with_frag_ind,
+		  pdev->stats.pub.rx.msdus_with_offload_ind);
 
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
 		  "  fwd to stack %d, fwd to fw %d, fwd to stack & fw  %d\n",
@@ -3668,7 +3698,7 @@ void ol_txrx_stats_display(ol_txrx_pdev_handle pdev)
 		  pdev->stats.pub.rx.intra_bss_fwd.packets_stack_n_fwd);
 
 	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
-		  "rx packets per HTT indication:\n"
+		  "Rx packets per HTT message:\n"
 		  "Single Packet  %d\n"
 		  " 2-10 Packets  %d\n"
 		  "11-20 Packets  %d\n"
@@ -4086,6 +4116,36 @@ void ol_txrx_ipa_uc_get_stat(ol_txrx_pdev_handle pdev)
 }
 #endif /* IPA_UC_OFFLOAD */
 
+/**
+ * ol_txrx_display_stats_help() - print statistics help
+ *
+ * Return: none
+ */
+static void ol_txrx_display_stats_help(void)
+{
+	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+				"iwpriv wlan0 dumpStats [option] - dump statistics");
+	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+				"iwpriv wlan0 clearStats [option] - clear statistics");
+	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+				"options:");
+	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+				"  1 -- TXRX Layer statistics");
+	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+				"  2 -- Bandwidth compute timer stats");
+	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+				"  3 -- TSO statistics");
+	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+				"  4 -- Network queue statistics");
+	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+				"  5 -- Flow control statistics");
+	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+				"  6 -- Per Layer statistics");
+	QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+				"  7 -- Copy engine interrupt statistics");
+
+}
+
 void ol_txrx_display_stats(uint16_t value)
 {
 	ol_txrx_pdev_handle pdev;
@@ -4131,8 +4191,7 @@ void ol_txrx_display_stats(uint16_t value)
 #endif
 #endif
 	default:
-		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
-					"%s: Unknown value", __func__);
+		ol_txrx_display_stats_help();
 		break;
 	}
 }
@@ -4175,8 +4234,7 @@ void ol_txrx_clear_stats(uint16_t value)
 		break;
 #endif
 	default:
-		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
-					"%s: Unknown value", __func__);
+		ol_txrx_display_stats_help();
 		break;
 	}
 }

core/dp/txrx/ol_txrx_flow_control.c

@@ -156,22 +156,18 @@ void ol_tx_dump_flow_pool_info(void)
 	struct ol_tx_flow_pool_t tmp_pool;
 
 
-	TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "Global Pool\n");
-	TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "Total %d :: Available %d\n",
+	TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "Global Pool");
+	TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "Total %d :: Available %d",
 		pdev->tx_desc.pool_size, pdev->tx_desc.num_free);
-	TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "Invalid flow_pool %d\n",
+	TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "Invalid flow_pool %d",
 		pdev->tx_desc.num_invalid_bin);
-
-	TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "No of pool map received %d\n",
+	TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "No of pool map received %d",
 		pdev->pool_stats.pool_map_count);
-	TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "No of pool unmap received %d\n",
+	TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "No of pool unmap received %d",
 		pdev->pool_stats.pool_unmap_count);
 	TXRX_PRINT(TXRX_PRINT_LEVEL_ERR,
-		"Pkt dropped due to unavailablity of pool %d\n",
+		"Pkt dropped due to unavailablity of pool %d",
 		pdev->pool_stats.pkt_drop_no_pool);
-	TXRX_PRINT(TXRX_PRINT_LEVEL_ERR,
-		"Pkt dropped due to unavailablity of descriptors %d\n",
-		pdev->pool_stats.pkt_drop_no_desc);
 
 	/*
 	 * Nested spin lock.
@@ -185,19 +181,23 @@ void ol_tx_dump_flow_pool_info(void)
 		qdf_mem_copy(&tmp_pool, pool, sizeof(tmp_pool));
 		qdf_spin_unlock_bh(&pool->flow_pool_lock);
 		qdf_spin_unlock_bh(&pdev->tx_desc.flow_pool_list_lock);
+		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "\n");
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR,
-			"Flow_pool_id %d :: status %d\n",
+			"Flow_pool_id %d :: status %d",
 			tmp_pool.flow_pool_id, tmp_pool.status);
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR,
-			"Total %d :: Available %d :: Deficient %d\n",
+			"Total %d :: Available %d :: Deficient %d",
 			tmp_pool.flow_pool_size, tmp_pool.avail_desc,
 			tmp_pool.deficient_desc);
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR,
-			"Start_TH %d :: Stop_TH %d\n",
+			"Start threshold %d :: Stop threshold %d",
 			 tmp_pool.start_th, tmp_pool.stop_th);
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR,
-			"Member flow_id  %d :: flow_type %d\n",
+			"Member flow_id  %d :: flow_type %d",
 			tmp_pool.member_flow_id, tmp_pool.flow_type);
+		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR,
+			"Pkt dropped due to unavailablity of descriptors %d",
+			tmp_pool.pkt_drop_no_desc);
 		qdf_spin_lock_bh(&pdev->tx_desc.flow_pool_list_lock);
 	}
 	qdf_spin_unlock_bh(&pdev->tx_desc.flow_pool_list_lock);

core/dp/txrx/ol_txrx_internal.h

@@ -689,6 +689,28 @@ NOT_IP_TCP:
 #endif
 
 #if defined(FEATURE_TSO_DEBUG)
+#define TXRX_STATS_TSO_HISTOGRAM(_pdev, _p_cntrs) \
+	do { \
+		if (_p_cntrs == 1) { \
+			TXRX_STATS_ADD(_pdev, pub.tx.tso.tso_hist.pkts_1, 1); \
+		} else if (_p_cntrs > 2 && _p_cntrs <= 5) {                   \
+			TXRX_STATS_ADD(_pdev,                                 \
+				pub.tx.tso.tso_hist.pkts_2_5, 1);             \
+		} else if (_p_cntrs > 5 && _p_cntrs <= 10) {                  \
+			TXRX_STATS_ADD(_pdev,                                 \
+				pub.tx.tso.tso_hist.pkts_6_10, 1);            \
+		} else if (_p_cntrs > 10 && _p_cntrs <= 15) {                 \
+			TXRX_STATS_ADD(_pdev,                                 \
+				pub.tx.tso.tso_hist.pkts_11_15, 1);           \
+		} else if (_p_cntrs > 15 && _p_cntrs <= 20) {                 \
+			TXRX_STATS_ADD(_pdev,                                 \
+				pub.tx.tso.tso_hist.pkts_16_20, 1);           \
+		} else if (_p_cntrs > 20) {                                   \
+			TXRX_STATS_ADD(_pdev,                                 \
+				pub.tx.tso.tso_hist.pkts_20_plus, 1);         \
+		}                                                             \
+	} while (0)
+
 #define TXRX_STATS_TSO_RESET_MSDU(pdev) \
 	do { \
 		int idx = TXRX_STATS_TSO_MSDU_IDX(pdev);\
@@ -705,6 +727,15 @@ NOT_IP_TCP:
 #define TXRX_STATS_TSO_MSDU_NUM_SEG(pdev, idx) \
 	pdev->stats.pub.tx.tso.tso_info.tso_msdu_info[idx].num_seg
 
+#define TXRX_STATS_TSO_MSDU_GSO_SIZE(pdev, idx) \
+	pdev->stats.pub.tx.tso.tso_info.tso_msdu_info[idx].gso_size
+
+#define TXRX_STATS_TSO_MSDU_TOTAL_LEN(pdev, idx) \
+	pdev->stats.pub.tx.tso.tso_info.tso_msdu_info[idx].total_len
+
+#define TXRX_STATS_TSO_MSDU_NR_FRAGS(pdev, idx) \
+	pdev->stats.pub.tx.tso.tso_info.tso_msdu_info[idx].nr_frags
+
 #define TXRX_STATS_TSO_CURR_MSDU(pdev) \
 	TXRX_STATS_TSO_MSDU(pdev, TXRX_STATS_TSO_MSDU_IDX(pdev))
 
@@ -718,7 +749,11 @@ NOT_IP_TCP:
 	TXRX_STATS_TSO_CURR_MSDU(pdev).tso_seg_idx
 
 #define TXRX_STATS_TSO_INC_SEG(pdev) \
-	TXRX_STATS_TSO_CURR_MSDU(pdev).num_seg++
+	do { \
+		TXRX_STATS_TSO_CURR_MSDU(pdev).num_seg++; \
+		TXRX_STATS_TSO_CURR_MSDU(pdev).num_seg &= \
+					 NUM_MAX_TSO_SEGS_MASK; \
+	} while (0)
 
 #define TXRX_STATS_TSO_RST_SEG(pdev) \
 	TXRX_STATS_TSO_CURR_MSDU(pdev).num_seg = 0
@@ -742,7 +777,17 @@ NOT_IP_TCP:
 #define TXRX_STATS_TSO_SEG_UPDATE(pdev, tso_seg) \
 	(TXRX_STATS_TSO_CURR_SEG(pdev) = tso_seg)
 
+#define TXRX_STATS_TSO_GSO_SIZE_UPDATE(pdev, size) \
+	(TXRX_STATS_TSO_CURR_MSDU(pdev).gso_size = size)
+
+#define TXRX_STATS_TSO_TOTAL_LEN_UPDATE(pdev, len) \
+	(TXRX_STATS_TSO_CURR_MSDU(pdev).total_len = len)
+
+#define TXRX_STATS_TSO_NUM_FRAGS_UPDATE(pdev, frags) \
+	(TXRX_STATS_TSO_CURR_MSDU(pdev).nr_frags = frags)
+
 #else
+#define TXRX_STATS_TSO_HISTOGRAM(_pdev, _p_cntrs)  /* no-op */
 #define TXRX_STATS_TSO_RESET_MSDU(pdev) /* no-op */
 #define TXRX_STATS_TSO_MSDU_IDX(pdev) /* no-op */
 #define TXRX_STATS_TSO_MSDU(pdev, idx) /* no-op */
@@ -757,6 +802,12 @@ NOT_IP_TCP:
 #define TXRX_STATS_TSO_INC_SEG(pdev) /* no-op */
 #define TXRX_STATS_TSO_RST_SEG(pdev) /* no-op */
 #define TXRX_STATS_TSO_RST_SEG_IDX(pdev) /* no-op */
+#define TXRX_STATS_TSO_GSO_SIZE_UPDATE(pdev, size) /* no-op */
+#define TXRX_STATS_TSO_TOTAL_LEN_UPDATE(pdev, len) /* no-op */
+#define TXRX_STATS_TSO_NUM_FRAGS_UPDATE(pdev, frags) /* no-op */
+#define TXRX_STATS_TSO_MSDU_GSO_SIZE(pdev, idx) /* no-op */
+#define TXRX_STATS_TSO_MSDU_TOTAL_LEN(pdev, idx) /* no-op */
+#define TXRX_STATS_TSO_MSDU_NR_FRAGS(pdev, idx) /* no-op */
 
 #endif /* FEATURE_TSO_DEBUG */
 

core/dp/txrx/ol_txrx_types.h

@@ -443,13 +443,11 @@ enum flow_pool_status {
  * @pool_map_count: flow pool map received
  * @pool_unmap_count: flow pool unmap received
  * @pkt_drop_no_pool: packets dropped due to unavailablity of pool
- * @pkt_drop_no_desc: packets dropped due to unavailablity of descriptors
  */
 struct ol_txrx_pool_stats {
 	uint16_t pool_map_count;
 	uint16_t pool_unmap_count;
 	uint16_t pkt_drop_no_pool;
-	uint16_t pkt_drop_no_desc;
 };
 
 /**
@@ -466,6 +464,7 @@ struct ol_txrx_pool_stats {
  * @stop_th: stop threshold
  * @start_th: start threshold
  * @freelist: tx descriptor freelist
+ * @pkt_drop_no_desc: drop due to no descriptors
  */
 struct ol_tx_flow_pool_t {
 	TAILQ_ENTRY(ol_tx_flow_pool_t) flow_pool_list_elem;
@@ -480,6 +479,7 @@ struct ol_tx_flow_pool_t {
 	uint16_t stop_th;
 	uint16_t start_th;
 	union ol_tx_desc_list_elem_t *freelist;
+	uint16_t pkt_drop_no_desc;
 };
 
 #endif

core/hdd/inc/wlan_hdd_main.h

@@ -805,6 +805,7 @@ typedef struct multicast_addr_list {
 struct hdd_netif_queue_stats {
 	uint16_t pause_count;
 	uint16_t unpause_count;
+	qdf_time_t total_pause_time;
 };
 
 /**

core/hdd/src/wlan_hdd_hostapd.c

@@ -2202,6 +2202,10 @@ static int __iw_softap_set_two_ints_getnone(struct net_device *dev,
 		       value[1], value[2]);
 		if (value[1] == DUMP_DP_TRACE)
 			qdf_dp_trace_dump_all(value[2]);
+		else if (value[1] == ENABLE_DP_TRACE_LIVE_MODE)
+			qdf_dp_trace_enable_live_mode();
+		else if (value[1] == CLEAR_DP_TRACE_BUFFER)
+			qdf_dp_trace_clear_buffer();
 		break;
 	case QCSAP_ENABLE_FW_PROFILE:
 		hddLog(LOG1, "QCSAP_ENABLE_FW_PROFILE: %d %d",

core/hdd/src/wlan_hdd_main.c

@@ -4782,6 +4782,23 @@ void wlan_hdd_deinit_tx_rx_histogram(hdd_context_t *hdd_ctx)
 	}
 }
 
+static uint8_t *convert_level_to_string(uint32_t level)
+{
+	switch (level) {
+	/* initialize the wlan sub system */
+	case WLAN_SVC_TP_NONE:
+		return "NONE";
+	case WLAN_SVC_TP_LOW:
+		return "LOW";
+	case WLAN_SVC_TP_MEDIUM:
+		return "MED";
+	case WLAN_SVC_TP_HIGH:
+		return "HIGH";
+	default:
+		return "INVAL";
+	}
+}
+
 
 /**
  * wlan_hdd_display_tx_rx_histogram() - display tx rx histogram
@@ -4794,32 +4811,42 @@ void wlan_hdd_display_tx_rx_histogram(hdd_context_t *hdd_ctx)
 	int i;
 
 #ifdef MSM_PLATFORM
-	hddLog(QDF_TRACE_LEVEL_ERROR, "BW Interval: %d curr_index %d",
-		hdd_ctx->config->busBandwidthComputeInterval,
-		hdd_ctx->hdd_txrx_hist_idx);
+	hddLog(QDF_TRACE_LEVEL_ERROR, "BW compute Interval: %dms",
+		hdd_ctx->config->busBandwidthComputeInterval);
 	hddLog(QDF_TRACE_LEVEL_ERROR,
 		"BW High TH: %d BW Med TH: %d BW Low TH: %d",
 		hdd_ctx->config->busBandwidthHighThreshold,
 		hdd_ctx->config->busBandwidthMediumThreshold,
 		hdd_ctx->config->busBandwidthLowThreshold);
+	hddLog(QDF_TRACE_LEVEL_ERROR, "Enable TCP DEL ACK: %d",
+		hdd_ctx->config->enable_tcp_delack);
 	hddLog(QDF_TRACE_LEVEL_ERROR, "TCP DEL High TH: %d TCP DEL Low TH: %d",
 		hdd_ctx->config->tcpDelackThresholdHigh,
 		hdd_ctx->config->tcpDelackThresholdLow);
+	hddLog(QDF_TRACE_LEVEL_ERROR,
+		"TCP TX HIGH TP TH: %d (Use to set tcp_output_bytes_limit)",
+		hdd_ctx->config->tcp_tx_high_tput_thres);
 #endif
 
+	hddLog(QDF_TRACE_LEVEL_ERROR, "Total entries: %d Current index: %d",
+		NUM_TX_RX_HISTOGRAM, hdd_ctx->hdd_txrx_hist_idx);
+
 	hddLog(QDF_TRACE_LEVEL_ERROR,
-		"index, total_rx, interval_rx, total_tx, interval_tx, next_vote_level, next_rx_level, next_tx_level");
+		"index, total_rx, interval_rx, total_tx, interval_tx, bus_bw_level, RX TP Level, TX TP Level");
 
 	for (i = 0; i < NUM_TX_RX_HISTOGRAM; i++) {
 		hddLog(QDF_TRACE_LEVEL_ERROR,
-			"%d: %llu, %llu, %llu, %llu, %d, %d, %d",
+			"%d: %llu, %llu, %llu, %llu, %s, %s, %s",
 			i, hdd_ctx->hdd_txrx_hist[i].total_rx,
 			hdd_ctx->hdd_txrx_hist[i].interval_rx,
 			hdd_ctx->hdd_txrx_hist[i].total_tx,
 			hdd_ctx->hdd_txrx_hist[i].interval_tx,
-			hdd_ctx->hdd_txrx_hist[i].next_vote_level,
-			hdd_ctx->hdd_txrx_hist[i].next_rx_level,
-			hdd_ctx->hdd_txrx_hist[i].next_tx_level);
+			convert_level_to_string(
+				hdd_ctx->hdd_txrx_hist[i].next_vote_level),
+			convert_level_to_string(
+				hdd_ctx->hdd_txrx_hist[i].next_rx_level),
+			convert_level_to_string(
+				hdd_ctx->hdd_txrx_hist[i].next_tx_level));
 	}
 	return;
 }
@@ -4850,29 +4877,27 @@ void wlan_hdd_display_netif_queue_history(hdd_context_t *hdd_ctx)
 	hdd_adapter_list_node_t *adapter_node = NULL, *next = NULL;
 	QDF_STATUS status;
 	int i;
-	qdf_time_t total, pause, unpause, curr_time;
+	qdf_time_t total, pause, unpause, curr_time, delta;
 
 	status = hdd_get_front_adapter(hdd_ctx, &adapter_node);
 	while (NULL != adapter_node && QDF_STATUS_SUCCESS == status) {
 		adapter = adapter_node->pAdapter;
 
+		hddLog(QDF_TRACE_LEVEL_ERROR,
+			"\nNetif queue operation statistics:");
 		hddLog(QDF_TRACE_LEVEL_ERROR,
 			"Session_id %d device mode %d",
 			adapter->sessionId, adapter->device_mode);
-
-		hddLog(QDF_TRACE_LEVEL_ERROR,
-			"Netif queue operation statistics:");
 		hddLog(QDF_TRACE_LEVEL_ERROR,
 			"Current pause_map value %x", adapter->pause_map);
 		curr_time = qdf_system_ticks();
 		total = curr_time - adapter->start_time;
+		delta = curr_time - adapter->last_time;
 		if (adapter->pause_map) {
-			pause = adapter->total_pause_time +
-				curr_time - adapter->last_time;
+			pause = adapter->total_pause_time + delta;
 			unpause = adapter->total_unpause_time;
 		} else {
-			unpause = adapter->total_unpause_time +
-				  curr_time - adapter->last_time;
+			unpause = adapter->total_unpause_time + delta;
 			pause = adapter->total_pause_time;
 		}
 		hddLog(QDF_TRACE_LEVEL_ERROR,
@@ -4881,19 +4906,30 @@ void wlan_hdd_display_netif_queue_history(hdd_context_t *hdd_ctx)
 			qdf_system_ticks_to_msecs(pause),
 			qdf_system_ticks_to_msecs(unpause));
 		hddLog(QDF_TRACE_LEVEL_ERROR,
-			"reason_type: pause_cnt: unpause_cnt");
+			"reason_type: pause_cnt: unpause_cnt: pause_time");
+
+		for (i = WLAN_CONTROL_PATH; i < WLAN_REASON_TYPE_MAX; i++) {
+			qdf_time_t pause_delta = 0;
+
+			if (adapter->pause_map & (1 << i))
+				pause_delta = delta;
 
-		for (i = 1; i < WLAN_REASON_TYPE_MAX; i++) {
 			hddLog(QDF_TRACE_LEVEL_ERROR,
-				"%s: %d: %d",
+				"%s: %d: %d: %ums",
 				hdd_reason_type_to_string(i),
 				adapter->queue_oper_stats[i].pause_count,
-				adapter->queue_oper_stats[i].unpause_count);
+				adapter->queue_oper_stats[i].unpause_count,
+				qdf_system_ticks_to_msecs(
+				adapter->queue_oper_stats[i].total_pause_time +
+				pause_delta));
 		}
 
 		hddLog(QDF_TRACE_LEVEL_ERROR,
-			"Netif queue operation history: current index %d",
-			adapter->history_index);
+			"\nNetif queue operation history:");
+		hddLog(QDF_TRACE_LEVEL_ERROR,
+			"Total entries: %d current index %d",
+			WLAN_HDD_MAX_HISTORY_ENTRY, adapter->history_index);
+
 		hddLog(QDF_TRACE_LEVEL_ERROR,
 			"index: time: action_type: reason_type: pause_map");
 

core/hdd/src/wlan_hdd_tx_rx.c

@@ -991,12 +991,25 @@ static void wlan_hdd_update_unpause_time(hdd_adapter_t *adapter)
  *
  * Return: none
  */
-static void wlan_hdd_update_pause_time(hdd_adapter_t *adapter)
+static void wlan_hdd_update_pause_time(hdd_adapter_t *adapter,
+	 uint32_t temp_map)
 {
 	qdf_time_t curr_time = qdf_system_ticks();
+	uint8_t i;
+	qdf_time_t pause_time;
 
-	adapter->total_pause_time += curr_time - adapter->last_time;
+	pause_time = curr_time - adapter->last_time;
+	adapter->total_pause_time += pause_time;
 	adapter->last_time = curr_time;
+
+	for (i = 0; i < WLAN_REASON_TYPE_MAX; i++) {
+		if (temp_map & (1 << i)) {
+			adapter->queue_oper_stats[i].total_pause_time +=
+								 pause_time;
+			break;
+		}
+	}
+
 }
 
 /**
@@ -1014,6 +1027,7 @@ static void wlan_hdd_update_pause_time(hdd_adapter_t *adapter)
 void wlan_hdd_netif_queue_control(hdd_adapter_t *adapter,
 	enum netif_action_type action, enum netif_reason_type reason)
 {
+	uint32_t temp_map;
 
 	if ((!adapter) || (WLAN_HDD_ADAPTER_MAGIC != adapter->magic) ||
 		 (!adapter->dev)) {
@@ -1044,20 +1058,22 @@ void wlan_hdd_netif_queue_control(hdd_adapter_t *adapter,
 
 	case WLAN_START_ALL_NETIF_QUEUE:
 		spin_lock_bh(&adapter->pause_map_lock);
+		temp_map = adapter->pause_map;
 		adapter->pause_map &= ~(1 << reason);
 		if (!adapter->pause_map) {
 			netif_tx_start_all_queues(adapter->dev);
-			wlan_hdd_update_pause_time(adapter);
+			wlan_hdd_update_pause_time(adapter, temp_map);
 		}
 		spin_unlock_bh(&adapter->pause_map_lock);
 		break;
 
 	case WLAN_WAKE_ALL_NETIF_QUEUE:
 		spin_lock_bh(&adapter->pause_map_lock);
+		temp_map = adapter->pause_map;
 		adapter->pause_map &= ~(1 << reason);
 		if (!adapter->pause_map) {
 			netif_tx_wake_all_queues(adapter->dev);
-			wlan_hdd_update_pause_time(adapter);
+			wlan_hdd_update_pause_time(adapter, temp_map);
 		}
 		spin_unlock_bh(&adapter->pause_map_lock);
 		break;
@@ -1077,10 +1093,11 @@ void wlan_hdd_netif_queue_control(hdd_adapter_t *adapter,
 	case WLAN_START_ALL_NETIF_QUEUE_N_CARRIER:
 		spin_lock_bh(&adapter->pause_map_lock);
 		netif_carrier_on(adapter->dev);
+		temp_map = adapter->pause_map;
 		adapter->pause_map &= ~(1 << reason);
 		if (!adapter->pause_map) {
 			netif_tx_start_all_queues(adapter->dev);
-			wlan_hdd_update_pause_time(adapter);
+			wlan_hdd_update_pause_time(adapter, temp_map);
 		}
 		spin_unlock_bh(&adapter->pause_map_lock);
 		break;

core/hdd/src/wlan_hdd_wext.c

@@ -9835,6 +9835,8 @@ static int __iw_set_two_ints_getnone(struct net_device *dev,
 			qdf_dp_trace_dump_all(value[2]);
 		else if (value[1] == ENABLE_DP_TRACE_LIVE_MODE)
 			qdf_dp_trace_enable_live_mode();
+		else if (value[1] == CLEAR_DP_TRACE_BUFFER)
+			qdf_dp_trace_clear_buffer();
 		break;
 	case WE_SET_MON_MODE_CHAN:
 		ret = wlan_hdd_set_mon_chan(pAdapter, value[1], value[2]);