qcacmn: Define few tx, rx and misc tracepoints

Define tracepoints for TCP, UDP, and other packets in
tx and rx. Also, define some miscellaneous to capture
delayed reg write and CE scheduling latency.

Change-Id: I1eafad7e367073060d742d7bf4ca3245d75cc25d
CRs-Fixed: 3080977

qdf/inc/qdf_tracepoint.h

@@ -23,4 +23,264 @@
 #if  !defined(_QDF_TRACEPOINT_H)
 #define _QDF_TRACEPOINT_H
 
+#include <i_qdf_tracepoint.h>
+#include <qdf_nbuf.h>
+#include <qdf_trace.h>
+
+#ifdef WLAN_TRACEPOINTS
+/**
+ * qdf_trace_dp_packet() - Trace packet in tx or rx path
+ * @nbuf: network buffer pointer
+ * @dir: tx or rx direction
+ * @tso_desc: TSO descriptor
+ * @enq_time: tx hw enqueue wall clock time in milliseconds
+ *
+ * Return: None
+ */
+void qdf_trace_dp_packet(qdf_nbuf_t nbuf, enum qdf_proto_dir dir,
+			 struct qdf_tso_seg_elem_t *tso_desc,
+			 uint64_t enq_time);
+#else
+static inline
+void qdf_trace_dp_packet(qdf_nbuf_t nbuf, enum qdf_proto_dir dir,
+			 struct qdf_tso_seg_elem_t *tso_desc,
+			 uint64_t enq_time)
+{
+}
+#endif
+
+/**
+ * qdf_trace_dp_rx_tcp_pkt_enabled() - Get the dp_rx_tcp_pkt tracepoint
+ *  enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool qdf_trace_dp_rx_tcp_pkt_enabled(void)
+{
+	return __qdf_trace_dp_rx_tcp_pkt_enabled();
+}
+
+/**
+ * qdf_trace_dp_rx_tcp_pkt() - Trace tcp packet in rx direction
+ * @nbuf: pointer to network buffer
+ * @tcp_seq_num: TCP sequence number
+ * @tcp_ack_num: TCP acknowlegment number
+ * @srcport: TCP source port
+ * @dstport: TCP destination port
+ * @latency: latency in milliseconds
+ *
+ * Return: None
+ */
+static inline
+void qdf_trace_dp_rx_tcp_pkt(qdf_nbuf_t nbuf, uint32_t tcp_seq_num,
+			     uint32_t tcp_ack_num, uint16_t srcport,
+			     uint16_t dstport, uint64_t latency)
+{
+	__qdf_trace_dp_rx_tcp_pkt(nbuf, tcp_seq_num, tcp_ack_num,
+				  srcport, dstport, latency);
+}
+
+/**
+ * qdf_trace_dp_tx_comp_tcp_pkt_enabled() - Get the dp_tx_comp_tcp_pkt
+ *  tracepoint enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool qdf_trace_dp_tx_comp_tcp_pkt_enabled(void)
+{
+	return __qdf_trace_dp_tx_comp_tcp_pkt_enabled();
+}
+
+/**
+ * qdf_trace_dp_tx_comp_tcp_pkt() - Trace tcp packet in tx completion
+ * @nbuf: pointer to network buffer
+ * @tcp_seq_num: TCP sequence number
+ * @tcp_ack_num: TCP acknowlegment number
+ * @srcport: TCP source port
+ * @dstport: TCP destination port
+ * @latency: latency in milliseconds
+ *
+ * Return: None
+ */
+static inline
+void qdf_trace_dp_tx_comp_tcp_pkt(qdf_nbuf_t nbuf, uint32_t tcp_seq_num,
+				  uint32_t tcp_ack_num, uint16_t srcport,
+				  uint16_t dstport, uint64_t latency)
+{
+	__qdf_trace_dp_tx_comp_tcp_pkt(nbuf, tcp_seq_num, tcp_ack_num, srcport,
+				       dstport, latency);
+}
+
+/**
+ * qdf_trace_dp_rx_udp_pkt_enabled() - Get the dp_rx_udp_pkt tracepoint
+ *  enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool qdf_trace_dp_rx_udp_pkt_enabled(void)
+{
+	return __qdf_trace_dp_rx_udp_pkt_enabled();
+}
+
+/**
+ * qdf_trace_dp_rx_udp_pkt() - Trace udp packet in rx direction
+ * @nbuf: pointer to network buffer
+ * @ip_id: ip identification field
+ * @srcport: UDP source port
+ * @dstport: UDP destination port
+ * @latency: latency in milliseconds
+ *
+ * Return: None
+ */
+static inline
+void qdf_trace_dp_rx_udp_pkt(qdf_nbuf_t nbuf, uint16_t ip_id,
+			     uint16_t srcport, uint16_t dstport,
+			     uint64_t latency)
+{
+	__qdf_trace_dp_rx_udp_pkt(nbuf, ip_id, srcport, dstport, latency);
+}
+
+/**
+ * qdf_trace_dp_tx_comp_udp_pkt_enabled() - Get the dp_tx_comp_udp_pkt
+ *  tracepoint enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool qdf_trace_dp_tx_comp_udp_pkt_enabled(void)
+{
+	return __qdf_trace_dp_tx_comp_udp_pkt_enabled();
+}
+
+/**
+ * qdf_trace_dp_tx_comp_udp_pkt() - Trace udp packet in tx completion
+ * @nbuf: pointer to network buffer
+ * @ip_id: ip identification field
+ * @srcport: UDP source port
+ * @dstport: UDP destination port
+ * @latency: latency in milliseconds
+ *
+ * Return: None
+ */
+static inline
+void qdf_trace_dp_tx_comp_udp_pkt(qdf_nbuf_t nbuf, uint16_t ip_id,
+				  uint16_t srcport, uint16_t dstport,
+				  uint64_t latency)
+{
+	__qdf_trace_dp_tx_comp_udp_pkt(nbuf, ip_id, srcport, dstport, latency);
+}
+
+/**
+ * qdf_trace_dp_rx_pkt_enabled() - Get the dp_rx_pkt tracepoint
+ *  enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool qdf_trace_dp_rx_pkt_enabled(void)
+{
+	return __qdf_trace_dp_rx_pkt_enabled();
+}
+
+/**
+ * qdf_trace_dp_rx_pkt() - Trace non-tcp/udp packet in rx direction
+ * @nbuf: pointer to network buffer
+ * @ether_type: type in ethernet header
+ * @latency: latency in milliseconds
+ *
+ * Return: None
+ */
+static inline
+void qdf_trace_dp_rx_pkt(qdf_nbuf_t nbuf, uint16_t ether_type,
+			 uint64_t latency)
+{
+	__qdf_trace_dp_rx_pkt(nbuf, ether_type, latency);
+}
+
+/**
+ * qdf_trace_dp_tx_comp_pkt_enabled() - Get the dp_tx_comp_pkt tracepoint
+ *  enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool qdf_trace_dp_tx_comp_pkt_enabled(void)
+{
+	return __qdf_trace_dp_tx_comp_pkt_enabled();
+}
+
+/**
+ * qdf_trace_dp_tx_comp_pkt() - Trace non-tcp/udp packet in rx direction
+ * @nbuf: pointer to network buffer
+ * @ether_type: type in ethernet header
+ * @latency: latency in milliseconds
+ *
+ * Return: None
+ */
+static inline
+void qdf_trace_dp_tx_comp_pkt(qdf_nbuf_t nbuf, uint16_t ether_type,
+			      uint64_t latency)
+{
+	__qdf_trace_dp_tx_comp_pkt(nbuf, ether_type, latency);
+}
+
+/**
+ * qdf_trace_dp_del_reg_write_enabled() - Get the dp_del_reg_write tracepoint
+ *  enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool qdf_trace_dp_del_reg_write_enabled(void)
+{
+	return __qdf_trace_dp_del_reg_write_enabled();
+}
+
+/**
+ * qdf_trace_dp_del_reg_write() - Trace delayed register writes
+ * @srng_id: srng id
+ * @enq_val: enqueue value
+ * @deq_val: dequeue value
+ * @enq_time: enqueue time in qtimer ticks
+ * @deq_time: dequeue time in qtimer ticks
+ *
+ * Return: None
+ */
+static inline
+void qdf_trace_dp_del_reg_write(uint8_t srng_id, uint32_t enq_val,
+				uint32_t deq_val, uint64_t enq_time,
+				uint64_t deq_time)
+{
+	__qdf_trace_dp_del_reg_write(srng_id, enq_val, deq_val, enq_time,
+				     deq_time);
+}
+
+/**
+ * qdf_trace_dp_ce_tasklet_sched_lat_enabled() - Get the dp_ce_tasklet_sched_lat
+ *  tracepoint enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool qdf_trace_dp_ce_tasklet_sched_latency_enabled(void)
+{
+	return __qdf_trace_dp_ce_tasklet_sched_latency_enabled();
+}
+
+/**
+ * qdf_trace_dp_ce_tasklet_sched_latency() - Trace ce tasklet scheduling
+ *  latency
+ * @ce_id: ce id
+ * @sched_latency: ce tasklet sched latency in nanoseconds
+ *
+ * Return: None
+ */
+static inline void
+qdf_trace_dp_ce_tasklet_sched_latency(uint8_t ce_id, uint64_t sched_latency)
+{
+	__qdf_trace_dp_ce_tasklet_sched_latency(ce_id, sched_latency);
+}
 #endif /* _QDF_TRACEPOINT_H */

qdf/linux/src/i_qdf_tracepoint.h

@@ -25,4 +25,238 @@
 
 #include <qdf_tracepoint_defs.h>
 
+/**
+ * __qdf_trace_dp_rx_tcp_pkt_enabled() - Get the dp_rx_tcp_pkt tracepoint
+ *  enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool __qdf_trace_dp_rx_tcp_pkt_enabled(void)
+{
+	return trace_dp_rx_tcp_pkt_enabled();
+}
+
+/**
+ * __qdf_trace_dp_rx_tcp_pkt() - Trace tcp packet in rx direction
+ * @skb: pointer to network buffer
+ * @tcp_seq_num: TCP sequence number
+ * @tcp_ack_num: TCP acknowlegment number
+ * @srcport: TCP source port
+ * @dstport: TCP destination port
+ * @latency: latency
+ *
+ * Return: None
+ */
+static inline
+void __qdf_trace_dp_rx_tcp_pkt(struct sk_buff *skb, uint32_t tcp_seq_num,
+			       uint32_t tcp_ack_num, uint16_t srcport,
+			       uint16_t dstport, uint64_t latency)
+{
+	trace_dp_rx_tcp_pkt(skb, tcp_seq_num, tcp_ack_num, srcport, dstport,
+			    latency);
+}
+
+/**
+ * __qdf_trace_dp_tx_comp_tcp_pkt_enabled() - Get the dp_tx_comp_tcp_pkt
+ *  tracepoint enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool __qdf_trace_dp_tx_comp_tcp_pkt_enabled(void)
+{
+	return trace_dp_tx_comp_tcp_pkt_enabled();
+}
+
+/**
+ * __qdf_trace_dp_tx_comp_tcp_pkt() - Trace tcp packet in tx completion
+ * @skb: pointer to network buffer
+ * @tcp_seq_num: TCP sequence number
+ * @tcp_ack_num: TCP acknowlegment number
+ * @srcport: TCP source port
+ * @dstport: TCP destination port
+ * @latency: latency
+ *
+ * Return: None
+ */
+static inline
+void __qdf_trace_dp_tx_comp_tcp_pkt(struct sk_buff *skb, uint32_t tcp_seq_num,
+				    uint32_t tcp_ack_num, uint16_t srcport,
+				    uint16_t dstport, uint64_t latency)
+{
+	trace_dp_tx_comp_tcp_pkt(skb, tcp_seq_num, tcp_ack_num, srcport,
+				 dstport, latency);
+}
+
+/**
+ * __qdf_trace_dp_rx_udp_pkt_enabled() - Get the dp_rx_udp_pkt tracepoint
+ *  enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool __qdf_trace_dp_rx_udp_pkt_enabled(void)
+{
+	return trace_dp_rx_udp_pkt_enabled();
+}
+
+/**
+ * __qdf_trace_dp_rx_udp_pkt() - Trace udp packet in rx direction
+ * @skb: pointer to network buffer
+ * @ip_id: ip identification field
+ * @srcport: UDP source port
+ * @dstport: UDP destination port
+ * @latency: latency
+ *
+ * Return: None
+ */
+static inline
+void __qdf_trace_dp_rx_udp_pkt(struct sk_buff *skb, uint16_t ip_id,
+			       uint16_t srcport, uint16_t dstport,
+			       uint64_t latency)
+{
+	trace_dp_rx_udp_pkt(skb, ip_id, srcport, dstport, latency);
+}
+
+/**
+ * __qdf_trace_dp_tx_comp_udp_pkt_enabled() - Get the dp_tx_comp_udp_pkt
+ *  tracepoint enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool __qdf_trace_dp_tx_comp_udp_pkt_enabled(void)
+{
+	return trace_dp_tx_comp_udp_pkt_enabled();
+}
+
+/**
+ * __qdf_trace_dp_tx_comp_udp_pkt() - Trace udp packet in tx completion
+ * @skb: pointer to network buffer
+ * @ip_id: ip identification field
+ * @srcport: UDP source port
+ * @dstport: UDP destination port
+ * @latency: latency
+ *
+ * Return: None
+ */
+static inline
+void __qdf_trace_dp_tx_comp_udp_pkt(struct sk_buff *skb, uint16_t ip_id,
+				    uint16_t srcport, uint16_t dstport,
+				    uint64_t latency)
+{
+	trace_dp_tx_comp_udp_pkt(skb, ip_id, srcport, dstport, latency);
+}
+
+/**
+ * __qdf_trace_dp_rx_pkt_enabled() - Get the dp_rx_pkt tracepoint
+ *  enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool __qdf_trace_dp_rx_pkt_enabled(void)
+{
+	return trace_dp_rx_pkt_enabled();
+}
+
+/**
+ * __qdf_trace_dp_rx_pkt() - Trace non-tcp/udp packet in rx direction
+ * @skb: pointer to network buffer
+ * @ether_type: type in ethernet header
+ * @latency: latency
+ *
+ * Return: None
+ */
+static inline
+void __qdf_trace_dp_rx_pkt(struct sk_buff *skb, uint16_t ether_type,
+			   uint64_t latency)
+{
+	trace_dp_rx_pkt(skb, ether_type, latency);
+}
+
+/**
+ * __qdf_trace_dp_tx_comp_pkt_enabled() - Get the dp_tx_comp_pkt tracepoint
+ *  enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool __qdf_trace_dp_tx_comp_pkt_enabled(void)
+{
+	return trace_dp_tx_comp_pkt_enabled();
+}
+
+/**
+ * __qdf_trace_dp_tx_comp_pkt() - Trace non-tcp/udp packet in rx direction
+ * @skb: pointer to network buffer
+ * @ether_type: type in ethernet header
+ * @latency: latency
+ *
+ * Return: None
+ */
+static inline
+void __qdf_trace_dp_tx_comp_pkt(struct sk_buff *skb, uint16_t ether_type,
+				uint64_t latency)
+{
+	trace_dp_tx_comp_pkt(skb, ether_type, latency);
+}
+
+/**
+ * __qdf_trace_dp_del_reg_write_enabled() - Get the dp_del_reg_write tracepoint
+ *  enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool __qdf_trace_dp_del_reg_write_enabled(void)
+{
+	return trace_dp_del_reg_write_enabled();
+}
+
+/**
+ * __qdf_trace_dp_del_reg_write() - Trace delayed register writes
+ * @srng_id: srng id
+ * @enq_val: enqueue value
+ * @deq_val: dequeue value
+ * @enq_time: enqueue time
+ * @deq_time: dequeue time
+ *
+ * Return: None
+ */
+static inline
+void __qdf_trace_dp_del_reg_write(uint8_t srng_id, uint32_t enq_val,
+				  uint32_t deq_val, uint64_t enq_time,
+				  uint64_t deq_time)
+{
+	trace_dp_del_reg_write(srng_id, enq_val, deq_val, enq_time,
+			       deq_time);
+}
+
+/**
+ * __qdf_trace_dp_ce_tasklet_sched_latency_enabled() - Get the
+ *  dp_ce_tasklet_sched_lat tracepoint enabled or disabled state
+ *
+ * Return: True if the tracepoint is enabled else false
+ */
+static inline
+bool __qdf_trace_dp_ce_tasklet_sched_latency_enabled(void)
+{
+	return trace_dp_ce_tasklet_sched_latency_enabled();
+}
+
+/**
+ * __qdf_trace_dp_ce_tasklet_sched_latency() - Trace ce tasklet scheduling
+ *  latency
+ * @ce_id: ce id
+ * @sched_latency: ce tasklet sched latency
+ *
+ * Return: None
+ */
+static inline void
+__qdf_trace_dp_ce_tasklet_sched_latency(uint8_t ce_id, uint64_t sched_latency)
+{
+	trace_dp_ce_tasklet_sched_latency(ce_id, sched_latency);
+}
 #endif /* _I_QDF_TRACEPOINT_H */

qdf/linux/src/qdf_tracepoint.c

@@ -20,3 +20,125 @@
 
 #define CREATE_TRACE_POINTS
 #include "qdf_tracepoint_defs.h"
+
+#ifdef WLAN_TRACEPOINTS
+static void qdf_trace_dp_tx_ip_packet(qdf_nbuf_t nbuf, uint8_t *trans_hdr,
+				      uint8_t ip_proto, uint16_t ip_id,
+				      struct qdf_tso_seg_elem_t *tso_desc,
+				      uint64_t latency)
+{
+	if (ip_proto == QDF_NBUF_TRAC_TCP_TYPE &&
+	    __qdf_trace_dp_tx_comp_tcp_pkt_enabled()) {
+		qdf_net_tcphdr_t *tcph = (qdf_net_tcphdr_t *)trans_hdr;
+		uint32_t tcp_seq;
+
+		if (tso_desc)
+			tcp_seq = tso_desc->seg.tso_flags.tcp_seq_num;
+		else
+			tcp_seq = qdf_ntohl(tcph->seq);
+
+		__qdf_trace_dp_tx_comp_tcp_pkt(nbuf, tcp_seq,
+					       qdf_ntohl(tcph->ack_seq),
+					       qdf_ntohs(tcph->source),
+					       qdf_ntohs(tcph->dest),
+					       latency);
+	} else if (ip_proto == QDF_NBUF_TRAC_UDP_TYPE &&
+		   __qdf_trace_dp_tx_comp_udp_pkt_enabled()) {
+		qdf_net_udphdr_t *udph = (qdf_net_udphdr_t *)trans_hdr;
+
+		__qdf_trace_dp_tx_comp_udp_pkt(nbuf, qdf_ntohs(ip_id),
+					       qdf_ntohs(udph->src_port),
+					       qdf_ntohs(udph->dst_port),
+					       latency);
+	}
+}
+
+static void qdf_trace_dp_rx_ip_packet(qdf_nbuf_t nbuf, uint8_t *trans_hdr,
+				      uint8_t ip_proto, uint16_t ip_id,
+				      uint64_t latency)
+{
+	if (ip_proto == QDF_NBUF_TRAC_TCP_TYPE &&
+	    __qdf_trace_dp_rx_tcp_pkt_enabled()) {
+		qdf_net_tcphdr_t *tcph = (qdf_net_tcphdr_t *)trans_hdr;
+
+		__qdf_trace_dp_rx_tcp_pkt(nbuf, qdf_ntohl(tcph->seq),
+					  qdf_ntohl(tcph->ack_seq),
+					  qdf_ntohs(tcph->source),
+					  qdf_ntohs(tcph->dest),
+					  latency);
+	} else if (ip_proto == QDF_NBUF_TRAC_UDP_TYPE &&
+		   __qdf_trace_dp_rx_udp_pkt_enabled()) {
+		qdf_net_udphdr_t *udph = (qdf_net_udphdr_t *)trans_hdr;
+
+		__qdf_trace_dp_rx_udp_pkt(nbuf, qdf_ntohs(ip_id),
+					  qdf_ntohs(udph->src_port),
+					  qdf_ntohs(udph->dst_port),
+					  latency);
+	}
+}
+
+void qdf_trace_dp_packet(qdf_nbuf_t nbuf, enum qdf_proto_dir dir,
+			 struct qdf_tso_seg_elem_t *tso_desc, uint64_t enq_time)
+{
+	uint8_t *data = qdf_nbuf_data(nbuf);
+	uint64_t latency;
+	uint16_t ether_type;
+	uint8_t ip_offset = QDF_NBUF_TRAC_IP_OFFSET;
+
+	if (dir == QDF_TX)
+		latency = (qdf_ktime_to_ms(qdf_ktime_real_get()) - enq_time);
+	else
+		latency = qdf_nbuf_get_timedelta_ms(nbuf);
+
+	ether_type = QDF_SWAP_U16(*(uint16_t *)(data +
+						QDF_NBUF_TRAC_ETH_TYPE_OFFSET));
+
+	if (unlikely(ether_type == QDF_ETH_TYPE_8021Q)) {
+		ether_type = QDF_SWAP_U16(*(uint16_t *)(data +
+					   QDF_NBUF_TRAC_VLAN_ETH_TYPE_OFFSET));
+		ip_offset = QDF_NBUF_TRAC_VLAN_IP_OFFSET;
+	} else if (unlikely(ether_type == QDF_ETH_TYPE_8021AD)) {
+		ether_type = QDF_SWAP_U16(*(uint16_t *)(data +
+				    QDF_NBUF_TRAC_DOUBLE_VLAN_ETH_TYPE_OFFSET));
+		ip_offset = QDF_NBUF_TRAC_DOUBLE_VLAN_IP_OFFSET;
+	}
+
+	switch (ether_type) {
+	case QDF_NBUF_TRAC_IPV4_ETH_TYPE:
+	case QDF_NBUF_TRAC_IPV6_ETH_TYPE:
+	{
+		uint8_t *net_hdr;
+		uint8_t *trans_hdr;
+		uint8_t ip_proto;
+		uint16_t ip_id = 0;
+
+		net_hdr = data + ip_offset;
+
+		if (ether_type == QDF_NBUF_TRAC_IPV4_ETH_TYPE) {
+			ip_proto = ((qdf_net_iphdr_t *)net_hdr)->ip_proto;
+			ip_id = ((qdf_net_iphdr_t *)net_hdr)->ip_id;
+			trans_hdr = net_hdr + QDF_NBUF_TRAC_IPV4_HEADER_SIZE;
+		} else {
+			ip_proto = ((qdf_net_ipv6hdr_t *)net_hdr)->ipv6_nexthdr;
+			trans_hdr = net_hdr + QDF_NBUF_TRAC_IPV6_HEADER_SIZE;
+		}
+
+		if (dir == QDF_TX)
+			qdf_trace_dp_tx_ip_packet(nbuf, trans_hdr, ip_proto,
+						  ip_id, tso_desc, latency);
+		else
+			qdf_trace_dp_rx_ip_packet(nbuf, trans_hdr, ip_proto,
+						  ip_id, latency);
+
+		break;
+	}
+	default:
+		if (dir == QDF_TX && __qdf_trace_dp_tx_comp_pkt_enabled())
+			__qdf_trace_dp_tx_comp_pkt(nbuf, ether_type, latency);
+		else if (__qdf_trace_dp_rx_pkt_enabled())
+			__qdf_trace_dp_rx_pkt(nbuf, ether_type, latency);
+
+		break;
+	}
+}
+#endif

qdf/linux/src/qdf_tracepoint_defs.h

@@ -25,6 +25,7 @@
 #define _QDF_TRACEPOINT_DEFS_H
 
 #include <linux/tracepoint.h>
+#include <linux/skbuff.h>
 
 #undef TRACE_SYSTEM
 #define TRACE_SYSTEM wlan
@@ -49,6 +50,154 @@
 		return false;                           \
 	}
 #endif /* WLAN_TRACEPOINTS */
+
+DECLARE_EVENT_CLASS(dp_trace_tcp_pkt_class,
+		    TP_PROTO(struct sk_buff *skb, uint32_t tcp_seq_num,
+			     uint32_t tcp_ack_num, uint16_t srcport,
+			     uint16_t dstport, uint64_t tdelta),
+		    TP_ARGS(skb, tcp_seq_num, tcp_ack_num, srcport,
+			    dstport, tdelta),
+		    TP_STRUCT__entry(
+			__field(void *, skb)
+			__field(uint32_t, tcp_seq_num)
+			__field(uint32_t, tcp_ack_num)
+			__field(uint16_t, srcport)
+			__field(uint16_t, dstport)
+			__field(uint64_t, tdelta)
+		    ),
+		    TP_fast_assign(
+			__entry->skb = skb;
+			__entry->tcp_seq_num = tcp_seq_num;
+			__entry->tcp_ack_num = tcp_ack_num;
+			__entry->srcport = srcport;
+			__entry->dstport = dstport;
+			__entry->tdelta = tdelta;
+		    ),
+		    TP_printk("skb=%pK seqnum=%u acknum=%u srcport=%u dstport=%u latency(ms)=%llu",
+			      __entry->skb, __entry->tcp_seq_num,
+			      __entry->tcp_ack_num, __entry->srcport,
+			      __entry->dstport, __entry->tdelta)
+);
+
+DEFINE_EVENT(dp_trace_tcp_pkt_class, dp_rx_tcp_pkt,
+	     TP_PROTO(struct sk_buff *skb, uint32_t tcp_seq_num,
+		      uint32_t tcp_ack_num, uint16_t srcport,
+		      uint16_t dstport, uint64_t tdelta),
+	     TP_ARGS(skb, tcp_seq_num, tcp_ack_num, srcport, dstport, tdelta)
+);
+
+DEFINE_EVENT(dp_trace_tcp_pkt_class, dp_tx_comp_tcp_pkt,
+	     TP_PROTO(struct sk_buff *skb, uint32_t tcp_seq_num,
+		      uint32_t tcp_ack_num, uint16_t srcport,
+		      uint16_t dstport, uint64_t tdelta),
+	     TP_ARGS(skb, tcp_seq_num, tcp_ack_num, srcport, dstport, tdelta)
+);
+
+DECLARE_EVENT_CLASS(dp_trace_udp_pkt_class,
+		    TP_PROTO(struct sk_buff *skb, uint16_t ip_id,
+			     uint16_t srcport, uint16_t dstport,
+			     uint64_t tdelta),
+		    TP_ARGS(skb, ip_id, srcport, dstport, tdelta),
+		    TP_STRUCT__entry(
+			__field(void *, skb)
+			__field(uint16_t, ip_id)
+			__field(uint16_t, srcport)
+			__field(uint16_t, dstport)
+			__field(uint64_t, tdelta)
+		    ),
+		    TP_fast_assign(
+			__entry->skb = skb;
+			__entry->ip_id = ip_id;
+			__entry->srcport = srcport;
+			__entry->dstport = dstport;
+			__entry->tdelta = tdelta;
+		    ),
+		    TP_printk("skb=%pK ip_id=%u srcport=%u dstport=%d latency(ms)=%llu",
+			      __entry->skb, __entry->ip_id,
+			      __entry->srcport, __entry->dstport,
+			      __entry->tdelta)
+);
+
+DEFINE_EVENT(dp_trace_udp_pkt_class, dp_rx_udp_pkt,
+	     TP_PROTO(struct sk_buff *skb, uint16_t ip_id, uint16_t srcport,
+		      uint16_t dstport, uint64_t tdelta),
+	     TP_ARGS(skb, ip_id, srcport, dstport, tdelta)
+);
+
+DEFINE_EVENT(dp_trace_udp_pkt_class, dp_tx_comp_udp_pkt,
+	     TP_PROTO(struct sk_buff *skb, uint16_t ip_id, uint16_t srcport,
+		      uint16_t dstport, uint64_t tdelta),
+	     TP_ARGS(skb, ip_id, srcport, dstport, tdelta)
+);
+
+DECLARE_EVENT_CLASS(dp_trace_pkt_class,
+		    TP_PROTO(struct sk_buff *skb, uint16_t ether_type,
+			     uint64_t tdelta),
+		    TP_ARGS(skb, ether_type, tdelta),
+		    TP_STRUCT__entry(
+			__field(void *, skb)
+			__field(uint16_t, ether_type)
+			__field(uint64_t, tdelta)
+		    ),
+		    TP_fast_assign(
+			__entry->skb = skb;
+			__entry->ether_type = ether_type;
+			__entry->tdelta = tdelta;
+		    ),
+		    TP_printk("skb=%pK ether_type=0x%x latency(ms)=%llu",
+			      __entry->skb, __entry->ether_type,
+			      __entry->tdelta)
+);
+
+DEFINE_EVENT(dp_trace_pkt_class, dp_rx_pkt,
+	     TP_PROTO(struct sk_buff *skb, uint16_t ether_type,
+		      uint64_t tdelta),
+	     TP_ARGS(skb, ether_type, tdelta)
+);
+
+DEFINE_EVENT(dp_trace_pkt_class, dp_tx_comp_pkt,
+	     TP_PROTO(struct sk_buff *skb, uint16_t ether_type,
+		      uint64_t tdelta),
+	     TP_ARGS(skb, ether_type, tdelta)
+);
+
+TRACE_EVENT(dp_del_reg_write,
+	    TP_PROTO(uint8_t srng_id, uint32_t enq_val, uint32_t deq_val,
+		     uint64_t enq_time, uint64_t deq_time),
+	    TP_ARGS(srng_id, enq_val, deq_val, enq_time, deq_time),
+	    TP_STRUCT__entry(
+		__field(uint8_t, srng_id)
+		__field(uint32_t, enq_val)
+		__field(uint32_t, deq_val)
+		__field(uint64_t, enq_time)
+		__field(uint64_t, deq_time)
+	    ),
+	    TP_fast_assign(
+		__entry->srng_id = srng_id;
+		__entry->enq_val = enq_val;
+		__entry->deq_val = deq_val;
+		__entry->enq_time = enq_time;
+		__entry->deq_time = deq_time;
+	    ),
+	    TP_printk("srng_id=%u enq_val=%u deq_val=%u enq_time=0x%llx deq_time=0x%llx",
+		      __entry->srng_id, __entry->enq_val, __entry->deq_val,
+		      __entry->enq_time, __entry->deq_time)
+);
+
+TRACE_EVENT(dp_ce_tasklet_sched_latency,
+	    TP_PROTO(uint8_t ce_id, uint64_t sched_latency),
+	    TP_ARGS(ce_id, sched_latency),
+	    TP_STRUCT__entry(
+		__field(uint8_t, ce_id)
+		__field(uint64_t, sched_latency)
+	    ),
+	    TP_fast_assign(
+		__entry->ce_id = ce_id;
+		__entry->sched_latency = sched_latency;
+	    ),
+	    TP_printk("ce_id=%u latency(ns)=%llu", __entry->ce_id,
+		      __entry->sched_latency)
+);
 #endif /* _QDF_TRACEPOINT_DEFS_H */
 
 /* Below should be outside the protection */