qcacld-3.0: Add Rx thread feature support for Dp component

Add Rx thread and Rx refill thread support for
DP componentization.

Change-Id: I2c0a0f7780280a0c2304f026d2580a81123de312
CRs-Fixed: 3316814

Kbuild

@@ -2120,21 +2120,6 @@ endif #LITHIUM/BERYLLIUM
 
 $(call add-wlan-objs,txrx,$(TXRX_OBJS))
 
-############ TXRX 3.0 ############
-TXRX3.0_DIR :=     core/dp/txrx3.0
-TXRX3.0_INC :=     -I$(WLAN_ROOT)/$(TXRX3.0_DIR)
-
-ifeq (y,$(filter y,$(CONFIG_LITHIUM) $(CONFIG_BERYLLIUM)))
-TXRX3.0_OBJS := $(TXRX3.0_DIR)/dp_txrx.o
-
-ifeq ($(CONFIG_WLAN_FEATURE_DP_RX_THREADS), y)
-TXRX3.0_OBJS += $(TXRX3.0_DIR)/dp_rx_thread.o
-endif
-
-endif #LITHIUM
-
-$(call add-wlan-objs,txrx30,$(TXRX3.0_OBJS))
-
 ifeq (y,$(filter y,$(CONFIG_LITHIUM) $(CONFIG_BERYLLIUM)))
 ############ DP 3.0 ############
 DP_INC := -I$(WLAN_COMMON_INC)/dp/inc \
@@ -2570,6 +2555,10 @@ ifeq (y,$(filter y,$(CONFIG_LITHIUM) $(CONFIG_BERYLLIUM)))
 WLAN_DP_COMP_OBJS += $(DP_COMP_CORE_DIR)/wlan_dp_prealloc.o
 endif
 
+ifeq ($(CONFIG_WLAN_FEATURE_DP_RX_THREADS), y)
+WLAN_DP_COMP_OBJS += $(DP_COMP_CORE_DIR)/wlan_dp_rx_thread.o
+endif
+
 ifeq ($(CONFIG_RX_FISA), y)
 WLAN_DP_COMP_OBJS += $(DP_COMP_CORE_DIR)/wlan_dp_fisa_rx.o
 WLAN_DP_COMP_OBJS += $(DP_COMP_CORE_DIR)/wlan_dp_rx_fst.o
@@ -3120,8 +3109,7 @@ INCS +=		$(WMA_INC) \
 		$(REGULATORY_INC) \
 		$(HTC_INC) \
 		$(DFS_INC) \
-		$(WCFG_INC) \
-		$(TXRX3.0_INC)
+		$(WCFG_INC)
 
 INCS +=		$(HIF_INC) \
 		$(BMI_INC) \

components/dp/core/inc/wlan_dp_prealloc.h

@@ -19,7 +19,7 @@
 #define _WLAN_DP_PREALLOC_H
 
 #include <wlan_objmgr_psoc_obj.h>
-#include <dp_rx_thread.h>
+#include <wlan_dp_rx_thread.h>
 #include <qdf_trace.h>
 #include <cdp_txrx_cmn_struct.h>
 #include <cdp_txrx_cmn.h>
@@ -91,8 +91,8 @@ void *dp_prealloc_get_coherent(uint32_t *size, void **base_vaddr_unaligned,
 /**
  * dp_prealloc_put_coherent() - puts back pre-alloc DP memory
  * @size: size of memory to be returned
- * @base_vaddr_unaligned: Unaligned virtual address.
- * @paddr_unaligned: Unaligned physical address.
+ * @vaddr_unligned: Unaligned virtual address.
+ * @paddr: Physical address
  *
  * Return: None
  */
@@ -100,7 +100,7 @@ void dp_prealloc_put_coherent(qdf_size_t size, void *vaddr_unligned,
 			      qdf_dma_addr_t paddr);
 
 /**
- * dp_prealloc_get_multi_page() - gets pre-alloc DP multi-pages memory
+ * dp_prealloc_get_multi_pages() - gets pre-alloc DP multi-pages memory
  * @src_type: the source that do memory allocation
  * @element_size: single element size
  * @element_num: total number of elements should be allocated
@@ -127,7 +127,7 @@ void dp_prealloc_put_multi_pages(uint32_t src_type,
 
 /**
  * dp_prealloc_get_consistent_mem_unaligned() - gets pre-alloc unaligned
-						consistent memory
+ *						consistent memory
  * @size: total memory size
  * @base_addr: pointer to dma address
  * @ring_type: HAL ring type that requires memory
@@ -140,7 +140,7 @@ void *dp_prealloc_get_consistent_mem_unaligned(qdf_size_t size,
 
 /**
  * dp_prealloc_put_consistent_mem_unaligned() - puts back pre-alloc unaligned
-						consistent memory
+ *						consistent memory
  * @va_unaligned: memory virtual address pointer
  *
  * Return: None

components/dp/core/inc/wlan_dp_priv.h

@@ -30,7 +30,7 @@
 #include "wlan_dp_cfg.h"
 #include "wlan_dp_objmgr.h"
 #include <cdp_txrx_misc.h>
-#include <dp_rx_thread.h>
+#include <wlan_dp_rx_thread.h>
 #include "qdf_periodic_work.h"
 #include <cds_api.h>
 #include "pld_common.h"
@@ -49,9 +49,9 @@
 #if defined(WLAN_FEATURE_DP_BUS_BANDWIDTH) && defined(FEATURE_RUNTIME_PM)
 /**
  * enum dp_rtpm_tput_policy_state - states to track runtime_pm tput policy
- * @RTPM_TPUT_POLICY_STATE_INVALID: invalid state
- * @RTPM_TPUT_POLICY_STATE_REQUIRED: state indicating runtime_pm is required
- * @RTPM_TPUT_POLICY_STATE_NOT_REQUIRED: state indicating runtime_pm is NOT
+ * @DP_RTPM_TPUT_POLICY_STATE_INVALID: invalid state
+ * @DP_RTPM_TPUT_POLICY_STATE_REQUIRED: state indicating runtime_pm is required
+ * @DP_RTPM_TPUT_POLICY_STATE_NOT_REQUIRED: state indicating runtime_pm is NOT
  * required
  */
 enum dp_rtpm_tput_policy_state {
@@ -77,6 +77,62 @@ struct dp_rtpm_tput_policy_context {
 
 /**
  * struct wlan_dp_psoc_cfg - DP configuration parameters.
+ * @tx_orphan_enable: Enable/Disable tx orphan
+ * @rx_mode: rx mode for packet processing
+ * @tx_comp_loop_pkt_limit: max # of packets to be processed
+ * @rx_reap_loop_pkt_limit: max # of packets to be reaped
+ * @rx_hp_oos_update_limit: max # of HP OOS (out of sync)
+ * @rx_softirq_max_yield_duration_ns: max duration for RX softirq
+ * @periodic_stats_timer_interval: Print selective stats on this specified
+ * interval
+ * @periodic_stats_timer_duration: duration for which periodic timer should run
+ * @bus_bw_super_high_threshold: bus bandwidth super high threshold
+ * @bus_bw_ultra_high_threshold: bus bandwidth ultra high threshold
+ * @bus_bw_very_high_threshold: bus bandwidth very high threshold
+ * @bus_bw_dbs_threshold: bus bandwidth for DBS mode threshold
+ * @bus_bw_high_threshold: bus bandwidth high threshold
+ * @bus_bw_medium_threshold: bandwidth threshold for medium bandwidth
+ * @bus_bw_low_threshold: bandwidth threshold for low bandwidth
+ * @bus_bw_compute_interval: bus bandwidth compute interval
+ * @enable_tcp_delack: enable Dynamic Configuration of Tcp Delayed Ack
+ * @enable_tcp_limit_output: enable TCP limit output
+ * @enable_tcp_adv_win_scale: enable  TCP adv window scaling
+ * @tcp_delack_thres_high: High Threshold inorder to trigger TCP Del Ack
+ * indication
+ * @tcp_delack_thres_low: Low Threshold inorder to trigger TCP Del Ack
+ * indication
+ * @tcp_tx_high_tput_thres: High Threshold inorder to trigger High Tx
+ * Throughput requirement.
+ * @tcp_delack_timer_count: Del Ack Timer Count inorder to trigger TCP Del Ack
+ * indication
+ * @enable_tcp_param_update: enable tcp parameter update
+ * @bus_low_cnt_threshold: Threshold count to trigger low Tput GRO flush skip
+ * @enable_latency_crit_clients: Enable the handling of latency critical clients
+ * * @del_ack_enable: enable Dynamic Configuration of Tcp Delayed Ack
+ * @del_ack_threshold_high: High Threshold inorder to trigger TCP delay ack
+ * @del_ack_threshold_low: Low Threshold inorder to trigger TCP delay ack
+ * @del_ack_timer_value: Timeout value (ms) to send out all TCP del ack frames
+ * @del_ack_pkt_count: The maximum number of TCP delay ack frames
+ * @rx_thread_ul_affinity_mask: CPU mask to affine Rx_thread
+ * @rx_thread_affinity_mask: CPU mask to affine Rx_thread
+ * @cpu_map_list: RPS map for different RX queues
+ * @multicast_replay_filter: enable filtering of replayed multicast packets
+ * @rx_wakelock_timeout: Amount of time to hold wakelock for RX unicast packets
+ * @num_dp_rx_threads: number of dp rx threads
+ * @enable_dp_trace: Enable/Disable DP trace
+ * @dp_trace_config: DP trace configuration
+ * @enable_nud_tracking: Enable/Disable nud tracking
+ * @pkt_bundle_threshold_high: tx bundle high threshold
+ * @pkt_bundle_threshold_low: tx bundle low threshold
+ * @pkt_bundle_timer_value: tx bundle timer value in ms
+ * @pkt_bundle_size: tx bundle size
+ * @dp_proto_event_bitmap: Control for which protocol type diag log should be
+ * sent
+ * @fisa_enable: Enable/Disable FISA
+ * @icmp_req_to_fw_mark_interval: Interval to mark the ICMP Request packet to
+ * be sent to FW.
+ * @lro_enable: Enable/Disable lro
+ * @gro_enable: Enable/Disable gro
  */
 struct wlan_dp_psoc_cfg {
 	bool tx_orphan_enable;
@@ -156,7 +212,7 @@ struct wlan_dp_psoc_cfg {
 };
 
 /**
- * struct tx_rx_histogram - structure to keep track of tx and rx packets
+ * struct tx_rx_histogram: structure to keep track of tx and rx packets
  *				received over 100ms intervals
  * @interval_rx:	# of rx packets received in the last 100ms interval
  * @interval_tx:	# of tx packets received in the last 100ms interval
@@ -169,9 +225,9 @@ struct wlan_dp_psoc_cfg {
  * @next_tx_level:	pld_bus_width_type voting level (high or low)
  *			determined on the basis of tx packets received in the
  *			last 100ms interval
- * @is_rx_pm_qos_high	Capture rx_pm_qos voting
- * @is_tx_pm_qos_high	Capture tx_pm_qos voting
- * @qtime		timestamp when the record is added
+ * @is_rx_pm_qos_high: Capture rx_pm_qos voting
+ * @is_tx_pm_qos_high: Capture tx_pm_qos voting
+ * @qtime: timestamp when the record is added
  *
  * The structure keeps track of throughput requirements of wlan driver.
  * An entry is added if either of next_vote_level, next_rx_level or
@@ -191,6 +247,12 @@ struct tx_rx_histogram {
 /**
  * struct dp_stats - DP stats
  * @tx_rx_stats : Tx/Rx debug stats
+ * @arp_stats: arp debug stats
+ * @dns_stats: dns debug stats
+ * @tcp_stats: tcp debug stats
+ * @icmpv4_stats: icmpv4 debug stats
+ * @dhcp_stats: dhcp debug stats
+ * @eapol_stats: eapol debug stats
  */
 struct dp_stats {
 	struct dp_tx_rx_stats tx_rx_stats;
@@ -203,7 +265,7 @@ struct dp_stats {
 };
 
 /**
- * struct dhcp_phase - Per Peer DHCP Phases
+ * enum dhcp_phase - Per Peer DHCP Phases
  * @DHCP_PHASE_ACK: upon receiving DHCP_ACK/NAK message in REQUEST phase or
  *         DHCP_DELINE message in OFFER phase
  * @DHCP_PHASE_DISCOVER: upon receiving DHCP_DISCOVER message in ACK phase
@@ -219,7 +281,7 @@ enum dhcp_phase {
 };
 
 /**
- * struct dhcp_nego_status - Per Peer DHCP Negotiation Status
+ * enum dhcp_nego_status - Per Peer DHCP Negotiation Status
  * @DHCP_NEGO_STOP: when the peer is in ACK phase or client disassociated
  * @DHCP_NEGO_IN_PROGRESS: when the peer is in DISCOVER or REQUEST
  *         (Renewal process) phase
@@ -229,7 +291,7 @@ enum dhcp_nego_status {
 	DHCP_NEGO_IN_PROGRESS
 };
 
-/**
+/*
  * Pending frame type of EAP_FAILURE, bit number used in "pending_eap_frm_type"
  * of sta_info.
  */
@@ -258,7 +320,7 @@ struct wlan_dp_conn_info {
  * struct link_monitoring - link speed monitoring related info
  * @enabled: Is link speed monitoring feature enabled
  * @rx_linkspeed_threshold: link speed good/bad threshold
- * @is_link_speed_good: true means link speed good, false means bad
+ * @is_rx_linkspeed_good: true means rx link speed good, false means bad
  */
 struct link_monitoring {
 	uint8_t enabled;
@@ -280,8 +342,30 @@ struct direct_link_info {
  * @intf_id: Interface ID
  * @node: list node for membership in the interface list
  * @vdev: object manager vdev context
+ * @vdev_lock: vdev spin lock
  * @dev: netdev reference
- * @stats: Netdev stats
+ * @dp_stats: Device TX/RX statistics
+ * @is_sta_periodic_stats_enabled: Indicate whether to display sta periodic
+ * stats
+ * @periodic_stats_timer_count: count of periodic stats timer
+ * @periodic_stats_timer_counter: periodic stats timer counter
+ * @sta_periodic_stats_lock: sta periodic stats lock
+ * @stats: netdev stats
+ * @con_status: con_status value
+ * @dad: dad value
+ * @pkt_type_bitmap: packet type bitmap value
+ * @track_arp_ip: track ARP ip
+ * @dns_payload: dns payload
+ * @track_dns_domain_len: dns domain length
+ * @track_src_port: track source port value
+ * @track_dest_port: track destination port value
+ * @track_dest_ipv4: track destination ipv4 value
+ * @prev_rx_packets: Rx packets received N/W interface
+ * @prev_tx_packets: Tx packets transmitted on N/W interface
+ * @prev_tx_bytes: Tx bytes transmitted on N/W interface
+ * @prev_fwd_tx_packets: forwarded tx packets count
+ * @prev_fwd_rx_packets: forwarded rx packets count
+ * @nud_tracking: NUD tracking
  * @mic_work: Work to handle MIC error
  * @num_active_task: Active task count
  * @sap_tx_block_mask: SAP TX block mask
@@ -388,20 +472,54 @@ struct dp_direct_link_context {
 
 /**
  * struct wlan_dp_psoc_context - psoc related data required for DP
+ * @psoc: object manager psoc context
  * @pdev: object manager pdev context
+ * @qdf_dev: qdf device
  * @dp_cfg: place holder for DP configuration
+ * @intf_list_lock: DP interfaces list lock
  * @intf_list: DP interfaces list
- * @cb_obj: DP callbacks registered from other modules
+ * @rps: rps
+ * @dynamic_rps: dynamic rps
+ * @enable_rxthread: Enable/Disable rx thread
+ * @enable_dp_rx_threads: Enable/Disable DP rx threads
+ * @napi_enable: Enable/Disable napi
+ * @dp_ops: DP callbacks registered from other modules
  * @sb_ops: South bound direction call backs registered in DP
  * @nb_ops: North bound direction call backs registered in DP
+ * @en_tcp_delack_no_lro: Enable/Disable tcp delack no lro
+ * @no_rx_offload_pkt_cnt: no of rx offload packet count
+ * @no_tx_offload_pkt_cnt: no of tx offload packet count
+ * @is_suspend: to check whether syetem suspend or not
+ * @is_wiphy_suspended: to check whether wiphy suspend or not
+ * @num_latency_critical_clients: num latency critical clients
+ * @high_bus_bw_request: high bus bandwidth request
+ * @bw_vote_time: bus bandwidth vote time
  * @bus_bw_work: work for periodically computing DDR bus bandwidth requirements
  * @cur_vote_level: Current vote level
+ * @prev_no_rx_offload_pkts: no of previous rx offload packets
+ * @prev_rx_offload_pkts: previous rx offload packets
+ * @prev_no_tx_offload_pkts: no of previous tx offload packets
+ * @prev_tx_offload_pkts: previous tx offload packets
+ * @cur_tx_level: Current Tx level
+ * @prev_tx: previous tx
+ * @low_tput_gro_enable: Enable/Disable low tput gro
  * @bus_bw_lock: Bus bandwidth work lock
  * @cur_rx_level: Current Rx level
+ * @bus_low_vote_cnt: bus low level count
+ * @disable_rx_ol_in_concurrency: disable RX offload in concurrency scenarios
+ * @disable_rx_ol_in_low_tput: disable RX offload in tput scenarios
+ * @txrx_hist_idx: txrx histogram index
+ * @rx_high_ind_cnt: rx high_ind count
+ * @receive_offload_cb: receive offload cb
+ * @dp_agg_param: DP aggregation parameter
  * @rtpm_tput_policy_ctx: Runtime Tput policy context
  * @txrx_hist: TxRx histogram
  * @bbm_ctx: bus bandwidth manager context
  * @dp_direct_link_ctx: DP Direct Link context
+ * @rx_skip_qdisc_chk_conc:rx skip qdisc check connection
+ * @arp_connectivity_map: ARP connectiviy map
+ * @rx_wake_lock: rx wake lock
+ * @ol_enable: Enable/Disable offload
  */
 struct wlan_dp_psoc_context {
 	struct wlan_objmgr_psoc *psoc;

core/dp/txrx3.0/dp_rx_thread.h → components/dp/core/inc/wlan_dp_rx_thread.h

@@ -17,14 +17,20 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
-#if !defined(__DP_RX_THREAD_H)
-#define __DP_RX_THREAD_H
+#if !defined(__WLAN_DP_RX_THREAD_H)
+#define __WLAN_DP_RX_THREAD_H
 
 #include <qdf_lock.h>
 #include <qdf_event.h>
 #include <qdf_threads.h>
 #include <wlan_objmgr_vdev_obj.h>
 #include "cfg_dp.h"
+#include <cdp_txrx_cmn_struct.h>
+#include <cdp_txrx_cmn.h>
+#include "wlan_cfg.h"
+#include "qdf_nbuf.h"
+#include "qdf_threads.h"
+#include "qdf_net_if.h"
 
 /* Maximum number of REO rings supported (for stats tracking) */
 #define DP_RX_TM_MAX_REO_RINGS WLAN_CFG_NUM_REO_DEST_RING
@@ -52,6 +58,8 @@ struct dp_rx_tm_handle_cmn;
  * @dropped_invalid_vdev: packets(nbuf_list) dropped due to no vdev
  * @rx_flushed: packets flushed after vdev delete
  * @dropped_invalid_peer: packets(nbuf_list) dropped due to no peer
+ * @dropped_invalid_os_rx_handles: packets(nbuf_list) dropped due to no os rx
+ * handles
  * @dropped_others: packets dropped due to other reasons
  * @dropped_enq_fail: packets dropped due to pending queue full
  * @rx_nbufq_loop_yield: rx loop yield counter
@@ -98,6 +106,7 @@ enum dp_rx_refill_thread_state {
  * @shutdown_event: handle of Event for DP Rx thread to signal shutdown
  * @vdev_del_event: handle of Event for vdev del thread to signal completion
  *		    for gro flush
+ * @gro_flush_ind: gro flush indication for DP Rx thread
  * @event_flag: event flag to post events to DP Rx thread
  * @nbuf_queue:nbuf queue used to store RX packets
  * @nbufq_len: length of the nbuf queue
@@ -106,6 +115,7 @@ enum dp_rx_refill_thread_state {
  * @rtm_handle_cmn: abstract RX TM handle. This allows access to the dp_rx_tm
  *		    structures via APIs.
  * @napi: napi to deliver packet to stack via GRO
+ * @wait_q: wait queue to conditionally wait on events for DP Rx thread
  * @netdev: dummy netdev to initialize the napi structure with
  */
 struct dp_rx_thread {
@@ -122,9 +132,9 @@ struct dp_rx_thread {
 	unsigned long aff_mask;
 	struct dp_rx_thread_stats stats;
 	struct dp_rx_tm_handle_cmn *rtm_handle_cmn;
-	struct napi_struct napi;
+	qdf_napi_struct napi;
 	qdf_wait_queue_head_t wait_q;
-	struct net_device netdev;
+	qdf_dummy_netdev_t netdev;
 };
 
 /**
@@ -196,6 +206,32 @@ enum dp_rx_gro_flush_code {
 	DP_RX_GRO_LOW_TPUT_FLUSH
 };
 
+/**
+ * struct dp_txrx_config - dp txrx configuration passed to dp txrx modules
+ * @enable_rx_threads: DP rx threads or not
+ */
+struct dp_txrx_config {
+	bool enable_rx_threads;
+};
+
+struct dp_txrx_handle_cmn;
+
+/**
+ * struct dp_txrx_handle - main dp txrx container handle
+ * @pdev: cdp_pdev pdev handle
+ * @soc: ol_txrx_soc_handle soc handle
+ * @refill_thread: rx refill thread infra handle
+ * @rx_tm_hdl: rx thread infrastructure handle
+ * @config: configuration for DP TXRX modules
+ */
+struct dp_txrx_handle {
+	ol_txrx_soc_handle soc;
+	struct cdp_pdev *pdev;
+	struct dp_rx_tm_handle rx_tm_hdl;
+	struct dp_rx_refill_thread refill_thread;
+	struct dp_txrx_config config;
+};
+
 /**
  * dp_rx_refill_thread_init() - Initialize DP Rx refill threads
  * @refill_thread: Contains over all rx refill thread info
@@ -243,7 +279,7 @@ QDF_STATUS dp_rx_tm_enqueue_pkt(struct dp_rx_tm_handle *rx_tm_hdl,
 
 /**
  * dp_rx_tm_gro_flush_ind() - flush GRO packets for a RX Context Id
- * @rx_tm_hdl: dp_rx_tm_handle containing the overall thread infrastructure
+ * @rx_tm_handle: dp_rx_tm_handle containing the overall thread infrastructure
  * @rx_ctx_id: RX Thread Context Id for which GRO flush needs to be done
  * @flush_code: flush code to differentiate low TPUT flush
  *
@@ -271,7 +307,7 @@ QDF_STATUS dp_rx_tm_suspend(struct dp_rx_tm_handle *rx_tm_handle);
 
 /**
  * dp_rx_tm_flush_by_vdev_id() - flush rx packets by vdev_id in all
-				 rx thread queues
+ * rx thread queues
  * @rx_tm_hdl: dp_rx_tm_handle containing the overall thread
  *             infrastructure
  * @vdev_id: vdev id for which packets are to be flushed
@@ -320,18 +356,20 @@ dp_rx_thread_get_txrx_handle(struct dp_rx_tm_handle_cmn *rx_tm_handle_cmn)
 
 /**
  * dp_rx_tm_get_napi_context() - get NAPI context for a RX CTX ID
- * @soc: ol_txrx_soc_handle object
  * @rx_ctx_id: RX context ID (RX thread ID) corresponding to which NAPI is
  *             needed
+ * @rx_tm_hdl: dp_rx_tm_handle containing the overall thread
+ *             infrastructure
  *
  * Return: NULL on failure, else pointer to NAPI corresponding to rx_ctx_id
  */
-struct napi_struct *dp_rx_tm_get_napi_context(struct dp_rx_tm_handle *rx_tm_hdl,
-					      uint8_t rx_ctx_id);
+qdf_napi_struct *dp_rx_tm_get_napi_context(struct dp_rx_tm_handle *rx_tm_hdl,
+					   uint8_t rx_ctx_id);
 
 /**
  * dp_rx_tm_set_cpu_mask() - set CPU mask for RX threads
- * @soc: ol_txrx_soc_handle object
+ * @rx_tm_hdl: dp_rx_tm_handle containing the overall thread
+ *             infrastructure
  * @new_mask: New CPU mask pointer
  *
  * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
@@ -339,4 +377,387 @@ struct napi_struct *dp_rx_tm_get_napi_context(struct dp_rx_tm_handle *rx_tm_hdl,
 QDF_STATUS dp_rx_tm_set_cpu_mask(struct dp_rx_tm_handle *rx_tm_hdl,
 				 qdf_cpu_mask *new_mask);
 
-#endif /* __DP_RX_THREAD_H */
+#ifdef FEATURE_WLAN_DP_RX_THREADS
+/**
+ * dp_txrx_get_cmn_hdl_frm_ext_hdl() - conversion func ext_hdl->txrx_handle_cmn
+ * @dp_ext_hdl: pointer to dp_txrx_handle structure
+ *
+ * Return: typecasted pointer of type - struct dp_txrx_handle_cmn
+ */
+static inline struct dp_txrx_handle_cmn *
+dp_txrx_get_cmn_hdl_frm_ext_hdl(struct dp_txrx_handle *dp_ext_hdl)
+{
+	return (struct dp_txrx_handle_cmn *)dp_ext_hdl;
+}
+
+/**
+ * dp_txrx_get_ext_hdl_frm_cmn_hdl() - conversion func txrx_handle_cmn->ext_hdl
+ * @txrx_cmn_hdl: pointer to dp_txrx_handle_cmn structure
+ *
+ * Return: typecasted pointer of type - struct dp_txrx_handle
+ */
+static inline struct dp_txrx_handle *
+dp_txrx_get_ext_hdl_frm_cmn_hdl(struct dp_txrx_handle_cmn *txrx_cmn_hdl)
+{
+	return (struct dp_txrx_handle *)txrx_cmn_hdl;
+}
+
+static inline ol_txrx_soc_handle
+dp_txrx_get_soc_from_ext_handle(struct dp_txrx_handle_cmn *txrx_cmn_hdl)
+{
+	struct dp_txrx_handle *dp_ext_hdl;
+
+	dp_ext_hdl = dp_txrx_get_ext_hdl_frm_cmn_hdl(txrx_cmn_hdl);
+
+	return dp_ext_hdl->soc;
+}
+
+/**
+ * dp_txrx_init() - initialize DP TXRX module
+ * @soc: ol_txrx_soc_handle
+ * @pdev_id: id of dp pdev handle
+ * @config: configuration for DP TXRX modules
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
+ */
+QDF_STATUS dp_txrx_init(ol_txrx_soc_handle soc, uint8_t pdev_id,
+			struct dp_txrx_config *config);
+
+/**
+ * dp_txrx_deinit() - de-initialize DP TXRX module
+ * @soc: ol_txrx_soc_handle
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
+ */
+QDF_STATUS dp_txrx_deinit(ol_txrx_soc_handle soc);
+
+/**
+ * dp_txrx_flush_pkts_by_vdev_id() - flush rx packets for a vdev_id
+ * @soc: ol_txrx_soc_handle object
+ * @vdev_id: vdev_id for which rx packets are to be flushed
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
+ */
+static inline QDF_STATUS dp_txrx_flush_pkts_by_vdev_id(ol_txrx_soc_handle soc,
+						       uint8_t vdev_id)
+{
+	struct dp_txrx_handle *dp_ext_hdl;
+	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
+
+	if (!soc) {
+		qdf_status = QDF_STATUS_E_INVAL;
+		goto ret;
+	}
+
+	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
+	if (!dp_ext_hdl) {
+		qdf_status = QDF_STATUS_E_FAULT;
+		goto ret;
+	}
+
+	qdf_status = dp_rx_tm_flush_by_vdev_id(&dp_ext_hdl->rx_tm_hdl, vdev_id);
+ret:
+	return qdf_status;
+}
+
+/**
+ * dp_txrx_resume() - resume all threads
+ * @soc: ol_txrx_soc_handle object
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
+ */
+static inline QDF_STATUS dp_txrx_resume(ol_txrx_soc_handle soc)
+{
+	struct dp_txrx_handle *dp_ext_hdl;
+	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
+	struct dp_rx_refill_thread *refill_thread;
+
+	if (!soc) {
+		qdf_status = QDF_STATUS_E_INVAL;
+		goto ret;
+	}
+
+	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
+	if (!dp_ext_hdl) {
+		qdf_status = QDF_STATUS_E_FAULT;
+		goto ret;
+	}
+
+	refill_thread = &dp_ext_hdl->refill_thread;
+	if (refill_thread->enabled) {
+		qdf_status = dp_rx_refill_thread_resume(refill_thread);
+		if (qdf_status != QDF_STATUS_SUCCESS)
+			return qdf_status;
+	}
+
+	qdf_status = dp_rx_tm_resume(&dp_ext_hdl->rx_tm_hdl);
+ret:
+	return qdf_status;
+}
+
+/**
+ * dp_txrx_suspend() - suspend all threads
+ * @soc: ol_txrx_soc_handle object
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
+ */
+static inline QDF_STATUS dp_txrx_suspend(ol_txrx_soc_handle soc)
+{
+	struct dp_txrx_handle *dp_ext_hdl;
+	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
+	struct dp_rx_refill_thread *refill_thread;
+
+	if (!soc) {
+		qdf_status = QDF_STATUS_E_INVAL;
+		goto ret;
+	}
+
+	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
+	if (!dp_ext_hdl) {
+		qdf_status = QDF_STATUS_E_FAULT;
+		goto ret;
+	}
+
+	refill_thread = &dp_ext_hdl->refill_thread;
+	if (refill_thread->enabled) {
+		qdf_status = dp_rx_refill_thread_suspend(refill_thread);
+		if (qdf_status != QDF_STATUS_SUCCESS)
+			return qdf_status;
+	}
+
+	qdf_status = dp_rx_tm_suspend(&dp_ext_hdl->rx_tm_hdl);
+	if (QDF_IS_STATUS_ERROR(qdf_status) && refill_thread->enabled)
+		dp_rx_refill_thread_resume(refill_thread);
+
+ret:
+	return qdf_status;
+}
+
+/**
+ * dp_rx_enqueue_pkt() - enqueue packet(s) into the thread
+ * @soc: ol_txrx_soc_handle object
+ * @nbuf_list: list of packets to be queued into the rx_thread
+ *
+ * The function accepts a list of skbs connected by the skb->next pointer and
+ * queues them into a RX thread to be sent to the stack.
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
+ */
+static inline
+QDF_STATUS dp_rx_enqueue_pkt(ol_txrx_soc_handle soc, qdf_nbuf_t nbuf_list)
+{
+	struct dp_txrx_handle *dp_ext_hdl;
+	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
+
+	if (!soc || !nbuf_list) {
+		qdf_status = QDF_STATUS_E_INVAL;
+		dp_err("invalid input params soc %pK nbuf %pK"
+		       , soc, nbuf_list);
+		goto ret;
+	}
+
+	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
+	if (!dp_ext_hdl) {
+		qdf_status = QDF_STATUS_E_FAULT;
+		goto ret;
+	}
+
+	qdf_status = dp_rx_tm_enqueue_pkt(&dp_ext_hdl->rx_tm_hdl, nbuf_list);
+ret:
+	return qdf_status;
+}
+
+/**
+ * dp_rx_gro_flush_ind() - Flush GRO packets for a given RX CTX Id
+ * @soc: ol_txrx_soc_handle object
+ * @rx_ctx_id: Context Id (Thread for which GRO packets need to be flushed)
+ * @flush_code: flush_code differentiating normal_flush from low_tput_flush
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
+ */
+static inline
+QDF_STATUS dp_rx_gro_flush_ind(ol_txrx_soc_handle soc, int rx_ctx_id,
+			       enum dp_rx_gro_flush_code flush_code)
+{
+	struct dp_txrx_handle *dp_ext_hdl;
+	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
+
+	if (!soc) {
+		qdf_status = QDF_STATUS_E_INVAL;
+		dp_err("invalid input param soc %pK", soc);
+		goto ret;
+	}
+
+	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
+	if (!dp_ext_hdl) {
+		qdf_status = QDF_STATUS_E_FAULT;
+		goto ret;
+	}
+
+	qdf_status = dp_rx_tm_gro_flush_ind(&dp_ext_hdl->rx_tm_hdl, rx_ctx_id,
+					    flush_code);
+ret:
+	return qdf_status;
+}
+
+/**
+ * dp_txrx_ext_dump_stats() - dump txrx external module stats
+ * @soc: ol_txrx_soc_handle object
+ * @stats_id: id  for the module whose stats are needed
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
+ */
+static inline QDF_STATUS dp_txrx_ext_dump_stats(ol_txrx_soc_handle soc,
+						uint8_t stats_id)
+{
+	struct dp_txrx_handle *dp_ext_hdl;
+	QDF_STATUS qdf_status;
+
+	if (!soc) {
+		dp_err("invalid input params soc %pK", soc);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
+	if (!dp_ext_hdl)
+		return QDF_STATUS_E_FAULT;
+
+	if (stats_id == CDP_DP_RX_THREAD_STATS)
+		qdf_status = dp_rx_tm_dump_stats(&dp_ext_hdl->rx_tm_hdl);
+	else
+		qdf_status = QDF_STATUS_E_INVAL;
+
+	return qdf_status;
+}
+
+/**
+ * dp_rx_get_napi_context() - get NAPI context for a RX CTX ID
+ * @soc: ol_txrx_soc_handle object
+ * @rx_ctx_id: RX context ID (RX thread ID) corresponding to which NAPI is
+ *             needed
+ *
+ * Return: NULL on failure, else pointer to NAPI corresponding to rx_ctx_id
+ */
+static inline
+qdf_napi_struct *dp_rx_get_napi_context(ol_txrx_soc_handle soc,
+					uint8_t rx_ctx_id)
+{
+	struct dp_txrx_handle *dp_ext_hdl;
+
+	if (!soc) {
+		dp_err("soc in NULL!");
+		return NULL;
+	}
+
+	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
+	if (!dp_ext_hdl) {
+		dp_err("dp_ext_hdl in NULL!");
+		return NULL;
+	}
+
+	return dp_rx_tm_get_napi_context(&dp_ext_hdl->rx_tm_hdl, rx_ctx_id);
+}
+
+/**
+ * dp_txrx_set_cpu_mask() - set CPU mask for RX threads
+ * @soc: ol_txrx_soc_handle object
+ * @new_mask: New CPU mask pointer
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
+ */
+static inline
+QDF_STATUS dp_txrx_set_cpu_mask(ol_txrx_soc_handle soc, qdf_cpu_mask *new_mask)
+{
+	struct dp_txrx_handle *dp_ext_hdl;
+	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
+
+	if (!soc) {
+		qdf_status = QDF_STATUS_E_INVAL;
+		goto ret;
+	}
+
+	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
+	if (!dp_ext_hdl) {
+		qdf_status = QDF_STATUS_E_FAULT;
+		goto ret;
+	}
+
+	qdf_status = dp_rx_tm_set_cpu_mask(&dp_ext_hdl->rx_tm_hdl, new_mask);
+
+ret:
+	return qdf_status;
+}
+
+#else
+
+static inline
+QDF_STATUS dp_txrx_init(ol_txrx_soc_handle soc, uint8_t pdev_id,
+			struct dp_txrx_config *config)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline QDF_STATUS dp_txrx_deinit(ol_txrx_soc_handle soc)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline QDF_STATUS dp_txrx_flush_pkts_by_vdev_id(ol_txrx_soc_handle soc,
+						       uint8_t vdev_id)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline QDF_STATUS dp_txrx_resume(ol_txrx_soc_handle soc)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline QDF_STATUS dp_txrx_suspend(ol_txrx_soc_handle soc)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline
+QDF_STATUS dp_rx_enqueue_pkt(ol_txrx_soc_handle soc, qdf_nbuf_t nbuf_list)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline
+QDF_STATUS dp_rx_gro_flush_ind(ol_txrx_soc_handle soc, int rx_ctx_id,
+			       enum dp_rx_gro_flush_code flush_code)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline QDF_STATUS dp_txrx_ext_dump_stats(ol_txrx_soc_handle soc,
+						uint8_t stats_id)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline
+qdf_napi_struct *dp_rx_get_napi_context(ol_txrx_soc_handle soc,
+					uint8_t rx_ctx_id)
+{
+	return NULL;
+}
+
+static inline
+QDF_STATUS dp_txrx_set_cpu_mask(ol_txrx_soc_handle soc, qdf_cpu_mask *new_mask)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+#endif /* FEATURE_WLAN_DP_RX_THREADS */
+
+/**
+ * dp_rx_tm_get_pending() - get number of frame in thread
+ * nbuf queue pending
+ * @soc: ol_txrx_soc_handle object
+ *
+ * Return: number of frames
+ */
+int dp_rx_tm_get_pending(ol_txrx_soc_handle soc);
+#endif /* __WLAN_DP_RX_THREAD_H */

components/dp/core/src/wlan_dp_bus_bandwidth.c

@@ -29,7 +29,7 @@
 #include "cds_api.h"
 #include <wlan_nlink_common.h>
 #include "wlan_ipa_ucfg_api.h"
-#include "dp_txrx.h"
+#include "wlan_dp_rx_thread.h"
 #include "wlan_mlme_vdev_mgr_interface.h"
 #include "hif.h"
 #include "qdf_trace.h"
@@ -43,9 +43,10 @@
 #include "wlan_cm_roam_api.h"
 
 #ifdef FEATURE_BUS_BANDWIDTH_MGR
-/**
- * bus_bw_table_default - default table which provides bus bandwidth level
- *  corresponding to a given connection mode and throughput level.
+/*
+ * bus_bw_table_default: default table which provides bus
+ * bandwidth level corresponding to a given connection mode and throughput
+ * level.
  */
 static bus_bw_table_type bus_bw_table_default = {
 	[QCA_WLAN_802_11_MODE_11B] = {BUS_BW_LEVEL_NONE, BUS_BW_LEVEL_1,
@@ -78,10 +79,10 @@ static bus_bw_table_type bus_bw_table_default = {
 				       BUS_BW_LEVEL_7, BUS_BW_LEVEL_8},
 };
 
-/**
- * bus_bw_table_low_latency - table which provides bus bandwidth level
- *  corresponding to a given connection mode and throughput level in low
- *  latency setting.
+/*
+ * bus_bw_table_low_latency: table which provides bus
+ * bandwidth level corresponding to a given connection mode and throughput
+ * level in low latency setting.
  */
 static bus_bw_table_type bus_bw_table_low_latency = {
 	[QCA_WLAN_802_11_MODE_11B] = {BUS_BW_LEVEL_NONE, BUS_BW_LEVEL_8,
@@ -1127,8 +1128,8 @@ static void wlan_dp_display_txrx_stats(struct wlan_dp_psoc_context *dp_ctx)
 
 /**
  * dp_display_periodic_stats() - Function to display periodic stats
- * @dp_ctx - handle to dp context
- * @bool data_in_interval - true, if data detected in bw time interval
+ * @dp_ctx: handle to dp context
+ * @data_in_interval: true, if data detected in bw time interval
  *
  * The periodicity is determined by dp_ctx->dp_cfg->periodic_stats_disp_time.
  * Stats show up in wlan driver logs.

components/dp/core/src/wlan_dp_rx_fst.c

@@ -25,7 +25,7 @@
 #include "dp_htt.h"
 #include "dp_internal.h"
 #include "hif.h"
-#include "dp_txrx.h"
+#include "wlan_dp_rx_thread.h"
 
 /* Timeout in milliseconds to wait for CMEM FST HTT response */
 #define DP_RX_FST_CMEM_RESP_TIMEOUT 2000

core/dp/txrx3.0/dp_rx_thread.c → components/dp/core/src/wlan_dp_rx_thread.c

@@ -17,7 +17,7 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <dp_txrx.h>
+#include <wlan_dp_rx_thread.h>
 #include "dp_peer.h"
 #include "dp_internal.h"
 #include "dp_types.h"
@@ -25,6 +25,14 @@
 #include <cdp_txrx_peer_ops.h>
 #include <cds_sched.h>
 #include "dp_rx.h"
+#include "wlan_dp_ucfg_api.h"
+#include "wlan_dp_prealloc.h"
+#include "wlan_dp_main.h"
+#include "wlan_dp_public_struct.h"
+#include "wlan_dp_ucfg_api.h"
+#include "qdf_nbuf.h"
+#include "qdf_threads.h"
+#include "qdf_net_if.h"
 
 /* Timeout in ms to wait for a DP rx thread */
 #ifdef HAL_CONFIG_SLUB_DEBUG_ON
@@ -42,7 +50,7 @@
 #if DP_RX_TM_DEBUG
 /**
  * dp_rx_tm_walk_skb_list() - Walk skb list and print members
- * @nbuf_list - nbuf list to print
+ * @nbuf_list: nbuf list to print
  *
  * Returns: None
  */
@@ -88,7 +96,7 @@ dp_rx_refill_thread_set_affinity(struct dp_rx_refill_thread *refill_thread)
 
 	qdf_thread_set_cpus_allowed_mask(refill_thread->task, &new_mask);
 
-	cpumap_print_to_pagebuf(false, new_mask_str, &new_mask);
+	qdf_thread_cpumap_print_to_pagebuf(false, new_mask_str, &new_mask);
 	dp_debug("Refill Thread CPU mask  %s", new_mask_str);
 }
 #else
@@ -99,12 +107,12 @@ dp_rx_refill_thread_set_affinity(struct dp_rx_refill_thread *refill_thread)
 #endif
 /**
  * dp_rx_tm_get_soc_handle() - get soc handle from struct dp_rx_tm_handle_cmn
- * @rx_tm_handle_cmn - rx thread manager cmn handle
+ * @rx_tm_handle_cmn: rx thread manager cmn handle
  *
  * Returns: ol_txrx_soc_handle on success, NULL on failure.
  */
-static inline
-ol_txrx_soc_handle dp_rx_tm_get_soc_handle(struct dp_rx_tm_handle_cmn *rx_tm_handle_cmn)
+static inline ol_txrx_soc_handle
+dp_rx_tm_get_soc_handle(struct dp_rx_tm_handle_cmn *rx_tm_handle_cmn)
 {
 	struct dp_txrx_handle_cmn *txrx_handle_cmn;
 	ol_txrx_soc_handle soc;
@@ -118,7 +126,7 @@ ol_txrx_soc_handle dp_rx_tm_get_soc_handle(struct dp_rx_tm_handle_cmn *rx_tm_han
 
 /**
  * dp_rx_tm_thread_dump_stats() - display stats for a rx_thread
- * @rx_thread - rx_thread pointer for which the stats need to be
+ * @rx_thread: rx_thread pointer for which the stats need to be
  *            displayed
  *
  * Returns: None
@@ -182,7 +190,7 @@ QDF_STATUS dp_rx_tm_dump_stats(struct dp_rx_tm_handle *rx_tm_hdl)
 #ifdef FEATURE_ALLOW_PKT_DROPPING
 /*
  * dp_check_and_update_pending() - Check and Set RX Pending flag
- * @tm_handle_cmn - DP thread pointer
+ * @tm_handle_cmn: DP thread pointer
  *
  * Returns: QDF_STATUS_SUCCESS on success or qdf error code on
  * failure
@@ -258,8 +266,8 @@ QDF_STATUS dp_check_and_update_pending(struct dp_rx_tm_handle_cmn
 
 /**
  * dp_rx_tm_thread_enqueue() - enqueue nbuf list into rx_thread
- * @rx_thread - rx_thread in which the nbuf needs to be queued
- * @nbuf_list - list of packets to be queued into the thread
+ * @rx_thread: rx_thread in which the nbuf needs to be queued
+ * @nbuf_list: list of packets to be queued into the thread
  *
  * Enqueue packet into rx_thread and wake it up. The function
  * moves the next pointer of the nbuf_list into the ext list of
@@ -395,7 +403,7 @@ dp_rx_tm_thread_gro_flush_ind(struct dp_rx_thread *rx_thread,
 
 /**
  * dp_rx_thread_adjust_nbuf_list() - create an nbuf list from the frag list
- * @head - nbuf list to be created
+ * @head: nbuf list to be created
  *
  * Returns: void
  */
@@ -415,7 +423,7 @@ static void dp_rx_thread_adjust_nbuf_list(qdf_nbuf_t head)
 
 /**
  * dp_rx_tm_thread_dequeue() - dequeue nbuf list from rx_thread
- * @rx_thread - rx_thread from which the nbuf needs to be dequeued
+ * @rx_thread: rx_thread from which the nbuf needs to be dequeued
  *
  * Returns: nbuf or nbuf_list dequeued from rx_thread
  */
@@ -433,7 +441,8 @@ static qdf_nbuf_t dp_rx_tm_thread_dequeue(struct dp_rx_thread *rx_thread)
 #ifdef CONFIG_SLUB_DEBUG_ON
 /**
  * dp_rx_thread_should_yield() - check whether rx loop should yield
- * @iter - iteration of packets received
+ * @iter: iteration of packets received
+ * @rx_thread: rx_thread which should yield
  *
  * Returns: should yield or not
  */
@@ -455,7 +464,7 @@ static inline bool dp_rx_thread_should_yield(struct dp_rx_thread *rx_thread,
 
 /**
  * dp_rx_thread_process_nbufq() - process nbuf queue of a thread
- * @rx_thread - rx_thread whose nbuf queue needs to be processed
+ * @rx_thread: rx_thread whose nbuf queue needs to be processed
  *
  * Returns: 0 on success, error code on failure
  */
@@ -531,12 +540,18 @@ static int dp_rx_thread_process_nbufq(struct dp_rx_thread *rx_thread)
 static void dp_rx_thread_gro_flush(struct dp_rx_thread *rx_thread,
 				   enum dp_rx_gro_flush_code gro_flush_code)
 {
-	dp_debug("flushing packets for thread %u", rx_thread->id);
-
-	local_bh_disable();
-	dp_rx_napi_gro_flush(&rx_thread->napi, gro_flush_code);
-	local_bh_enable();
+	struct wlan_dp_psoc_context *dp_ctx;
 
+	dp_ctx =  dp_get_context();
+	if (!dp_ctx) {
+		dp_err("DP context is NULL");
+		return;
+	}
+	dp_debug("flushing packets for thread %u", rx_thread->id);
+	qdf_local_bh_disable();
+	dp_ctx->dp_ops.dp_rx_thread_napi_gro_flush(&rx_thread->napi,
+						   gro_flush_code);
+	qdf_local_bh_enable();
 	rx_thread->stats.gro_flushes++;
 }
 
@@ -560,8 +575,8 @@ dp_rx_should_flush(struct dp_rx_thread *rx_thread)
 
 /**
  * dp_rx_thread_sub_loop() - rx thread subloop
- * @rx_thread - rx_thread to be processed
- * @shutdown - pointer to shutdown variable
+ * @rx_thread: rx_thread to be processed
+ * @shutdown: pointer to shutdown variable
  *
  * The function handles shutdown and suspend events from other
  * threads and processes nbuf queue of a rx thread. In case a
@@ -634,6 +649,7 @@ static int dp_rx_thread_loop(void *arg)
 	struct dp_rx_thread *rx_thread = arg;
 	bool shutdown = false;
 	int status;
+	QDF_STATUS status_intr;
 	struct dp_rx_tm_handle_cmn *tm_handle_cmn;
 
 	if (!arg) {
@@ -662,8 +678,8 @@ static int dp_rx_thread_loop(void *arg)
 				 qdf_atomic_test_bit(RX_VDEV_DEL_EVENT,
 						     &rx_thread->event_flag));
 		dp_debug("woken up");
-
-		if (status == -ERESTARTSYS) {
+		status_intr = qdf_status_from_os_return(status);
+		if (status_intr == QDF_STATUS_E_RESTART) {
 			QDF_DEBUG_PANIC("wait_event_interruptible returned -ERESTARTSYS");
 			break;
 		}
@@ -718,6 +734,7 @@ static int dp_rx_refill_thread_loop(void *arg)
 	struct dp_rx_refill_thread *rx_thread = arg;
 	bool shutdown = false;
 	int status;
+	QDF_STATUS status_intr;
 
 	if (!arg) {
 		dp_err("bad Args passed");
@@ -740,12 +757,14 @@ static int dp_rx_refill_thread_loop(void *arg)
 				 qdf_atomic_test_bit(RX_REFILL_SUSPEND_EVENT,
 						     &rx_thread->event_flag));
 
-		if (status == -ERESTARTSYS) {
+		status_intr = qdf_status_from_os_return(status);
+		if (status_intr == QDF_STATUS_E_RESTART) {
 			QDF_DEBUG_PANIC("wait_event_interruptible returned -ERESTARTSYS");
 			break;
 		}
 		dp_rx_refill_thread_sub_loop(rx_thread, &shutdown);
-		qdf_atomic_clear_bit(RX_REFILL_POST_EVENT, &rx_thread->event_flag);
+		qdf_atomic_clear_bit(RX_REFILL_POST_EVENT,
+				     &rx_thread->event_flag);
 	}
 
 	/* If we get here the scheduler thread must exit */
@@ -763,7 +782,7 @@ static int dp_rx_refill_thread_loop(void *arg)
  *
  * Return: 0 as it is not supposed to be polled at all as it is not scheduled.
  */
-static int dp_rx_tm_thread_napi_poll(struct napi_struct *napi, int budget)
+static int dp_rx_tm_thread_napi_poll(qdf_napi_struct *napi, int budget)
 {
 	QDF_DEBUG_PANIC("this napi_poll should not be polled as we don't schedule it");
 
@@ -779,10 +798,10 @@ static int dp_rx_tm_thread_napi_poll(struct napi_struct *napi, int budget)
 static void dp_rx_tm_thread_napi_init(struct dp_rx_thread *rx_thread)
 {
 	/* Todo - optimize to use only one dummy netdev for all thread napis */
-	init_dummy_netdev(&rx_thread->netdev);
-	netif_napi_add(&rx_thread->netdev, &rx_thread->napi,
-		       dp_rx_tm_thread_napi_poll, 64);
-	napi_enable(&rx_thread->napi);
+	qdf_net_if_create_dummy_if((struct qdf_net_if *)&rx_thread->netdev);
+	qdf_netif_napi_add(&rx_thread->netdev, &rx_thread->napi,
+			   dp_rx_tm_thread_napi_poll, 64);
+	qdf_napi_enable(&rx_thread->napi);
 }
 
 /**
@@ -793,7 +812,7 @@ static void dp_rx_tm_thread_napi_init(struct dp_rx_thread *rx_thread)
  */
 static void dp_rx_tm_thread_napi_deinit(struct dp_rx_thread *rx_thread)
 {
-	netif_napi_del(&rx_thread->napi);
+	qdf_netif_napi_del(&rx_thread->napi);
 }
 
 /*
@@ -980,7 +999,7 @@ ret:
 }
 
 /**
- * dp_rx_tm_resume() - suspend DP RX threads
+ * dp_rx_tm_suspend() - suspend DP RX threads
  * @rx_tm_hdl: dp_rx_tm_handle containing the overall thread
  *            infrastructure
  *
@@ -1082,9 +1101,9 @@ suspend_fail:
 
 /**
  * dp_rx_thread_flush_by_vdev_id() - flush rx packets by vdev_id in
-				     a particular rx thread queue
- * @rx_thread - rx_thread pointer of the queue from which packets are
- *              to be flushed out
+ * a particular rx thread queue
+ * @rx_thread: rx_thread pointer of the queue from which packets are
+ * to be flushed out
  * @vdev_id: vdev id for which packets are to be flushed
  * @wait_timeout: wait time value for rx thread to complete flush
  *
@@ -1117,7 +1136,7 @@ QDF_STATUS dp_rx_thread_flush_by_vdev_id(struct dp_rx_thread *rx_thread,
 	qdf_nbuf_queue_head_unlock(&rx_thread->nbuf_queue);
 	unlock_time = qdf_get_log_timestamp();
 	dp_info("Lock held time: %llu us",
-			qdf_log_timestamp_to_usecs(unlock_time - lock_time));
+		qdf_log_timestamp_to_usecs(unlock_time - lock_time));
 
 	while (nbuf_list_head) {
 		nbuf_list_next = qdf_nbuf_queue_next(nbuf_list_head);
@@ -1135,7 +1154,7 @@ QDF_STATUS dp_rx_thread_flush_by_vdev_id(struct dp_rx_thread *rx_thread,
 	qdf_wake_up_interruptible(&rx_thread->wait_q);
 
 	qdf_status = qdf_wait_single_event(&rx_thread->vdev_del_event,
-					    wait_timeout);
+					   wait_timeout);
 
 	if (QDF_IS_STATUS_SUCCESS(qdf_status))
 		dp_debug("thread:%d napi gro flush successfully",
@@ -1159,9 +1178,9 @@ QDF_STATUS dp_rx_thread_flush_by_vdev_id(struct dp_rx_thread *rx_thread,
 
 /**
  * dp_rx_tm_flush_by_vdev_id() - flush rx packets by vdev_id in all
-				 rx thread queues
+ * rx thread queues
  * @rx_tm_hdl: dp_rx_tm_handle containing the overall thread
- *             infrastructure
+ * infrastructure
  * @vdev_id: vdev id for which packets are to be flushed
  *
  * Return: QDF_STATUS_SUCCESS
@@ -1217,7 +1236,7 @@ QDF_STATUS dp_rx_tm_flush_by_vdev_id(struct dp_rx_tm_handle *rx_tm_hdl,
 /**
  * dp_rx_tm_resume() - resume DP RX threads
  * @rx_tm_hdl: dp_rx_tm_handle containing the overall thread
- *            infrastructure
+ * infrastructure
  *
  * Return: QDF_STATUS_SUCCESS on resume success. QDF error otherwise.
  */
@@ -1299,7 +1318,6 @@ static QDF_STATUS dp_rx_tm_shutdown(struct dp_rx_tm_handle *rx_tm_hdl)
 		qdf_wake_up_interruptible(&rx_tm_hdl->rx_thread[i]->wait_q);
 	}
 
-
 	for (i = 0; i < rx_tm_hdl->num_dp_rx_threads; i++) {
 		if (!rx_tm_hdl->rx_thread[i] ||
 		    rx_tm_hdl->state == DP_RX_THREADS_INVALID)
@@ -1315,13 +1333,14 @@ static QDF_STATUS dp_rx_tm_shutdown(struct dp_rx_tm_handle *rx_tm_hdl)
 /**
  * dp_rx_tm_deinit() - de-initialize RX thread infrastructure
  * @rx_tm_hdl: dp_rx_tm_handle containing the overall thread
- *            infrastructure
+ * infrastructure
  *
  * Return: QDF_STATUS_SUCCESS
  */
 QDF_STATUS dp_rx_tm_deinit(struct dp_rx_tm_handle *rx_tm_hdl)
 {
 	int i = 0;
+
 	if (!rx_tm_hdl->rx_thread) {
 		dp_err("rx_tm_hdl->rx_thread not initialized!");
 		return QDF_STATUS_SUCCESS;
@@ -1346,7 +1365,7 @@ QDF_STATUS dp_rx_tm_deinit(struct dp_rx_tm_handle *rx_tm_hdl)
 /**
  * dp_rx_tm_select_thread() - select a DP RX thread for a nbuf
  * @rx_tm_hdl: dp_rx_tm_handle containing the overall thread
- *            infrastructure
+ * infrastructure
  * @reo_ring_num: REO ring number corresponding to the thread
  *
  * The function relies on the presence of QDF_NBUF_CB_RX_CTX_ID passed to it
@@ -1394,8 +1413,8 @@ dp_rx_tm_gro_flush_ind(struct dp_rx_tm_handle *rx_tm_hdl, int rx_ctx_id,
 	return QDF_STATUS_SUCCESS;
 }
 
-struct napi_struct *dp_rx_tm_get_napi_context(struct dp_rx_tm_handle *rx_tm_hdl,
-					      uint8_t rx_ctx_id)
+qdf_napi_struct *dp_rx_tm_get_napi_context(struct dp_rx_tm_handle *rx_tm_hdl,
+					   uint8_t rx_ctx_id)
 {
 	uint8_t selected_thread_id;
 
@@ -1417,3 +1436,177 @@ QDF_STATUS dp_rx_tm_set_cpu_mask(struct dp_rx_tm_handle *rx_tm_hdl,
 	}
 	return QDF_STATUS_SUCCESS;
 }
+
+/**
+ * dp_rx_refill_thread_schedule() - Schedule rx refill thread
+ * @soc: ol_txrx_soc_handle object
+ *
+ */
+#ifdef WLAN_FEATURE_RX_PREALLOC_BUFFER_POOL
+static void dp_rx_refill_thread_schedule(ol_txrx_soc_handle soc)
+{
+	struct dp_rx_refill_thread *rx_thread;
+	struct dp_txrx_handle *dp_ext_hdl;
+
+	if (!soc)
+		return;
+
+	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
+	if (!dp_ext_hdl)
+		return;
+
+	rx_thread = &dp_ext_hdl->refill_thread;
+	qdf_set_bit(RX_REFILL_POST_EVENT, &rx_thread->event_flag);
+	qdf_wake_up_interruptible(&rx_thread->wait_q);
+}
+#else
+static void dp_rx_refill_thread_schedule(ol_txrx_soc_handle soc)
+{
+}
+#endif
+
+/**
+ * dp_get_rx_threads_num() - Get number of threads in use
+ * @soc: ol_txrx_soc_handle object
+ *
+ * Return: number of threads
+ */
+static uint8_t dp_get_rx_threads_num(ol_txrx_soc_handle soc)
+{
+	return cdp_get_num_rx_contexts(soc);
+}
+
+QDF_STATUS dp_txrx_init(ol_txrx_soc_handle soc, uint8_t pdev_id,
+			struct dp_txrx_config *config)
+{
+	struct dp_txrx_handle *dp_ext_hdl;
+	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
+	uint8_t num_dp_rx_threads;
+	struct dp_pdev *pdev;
+	struct dp_soc *dp_soc;
+
+	if (qdf_unlikely(!soc)) {
+		dp_err("soc is NULL");
+		return 0;
+	}
+
+	pdev = dp_get_pdev_from_soc_pdev_id_wifi3(cdp_soc_t_to_dp_soc(soc),
+						  pdev_id);
+	if (!pdev) {
+		dp_err("pdev is NULL");
+		return 0;
+	}
+
+	dp_ext_hdl = qdf_mem_malloc(sizeof(*dp_ext_hdl));
+	if (!dp_ext_hdl) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_NOMEM;
+	}
+
+	dp_info("dp_txrx_handle allocated");
+	dp_ext_hdl->soc = soc;
+	dp_ext_hdl->pdev = dp_pdev_to_cdp_pdev(pdev);
+	cdp_soc_set_dp_txrx_handle(soc, dp_ext_hdl);
+	qdf_mem_copy(&dp_ext_hdl->config, config, sizeof(*config));
+	dp_ext_hdl->rx_tm_hdl.txrx_handle_cmn =
+				dp_txrx_get_cmn_hdl_frm_ext_hdl(dp_ext_hdl);
+
+	dp_soc = cdp_soc_t_to_dp_soc(soc);
+	if (wlan_cfg_is_rx_refill_buffer_pool_enabled(dp_soc->wlan_cfg_ctx)) {
+		dp_ext_hdl->refill_thread.soc = soc;
+		dp_ext_hdl->refill_thread.enabled = true;
+		qdf_status =
+			dp_rx_refill_thread_init(&dp_ext_hdl->refill_thread);
+		if (qdf_status != QDF_STATUS_SUCCESS) {
+			dp_err("Failed to initialize RX refill thread status:%d",
+			       qdf_status);
+			return qdf_status;
+		}
+		cdp_register_rx_refill_thread_sched_handler(soc,
+							    dp_rx_refill_thread_schedule);
+	}
+
+	num_dp_rx_threads = dp_get_rx_threads_num(soc);
+	dp_info("%d RX threads in use", num_dp_rx_threads);
+
+	if (dp_ext_hdl->config.enable_rx_threads) {
+		qdf_status = dp_rx_tm_init(&dp_ext_hdl->rx_tm_hdl,
+					   num_dp_rx_threads);
+	}
+
+	return qdf_status;
+}
+
+QDF_STATUS dp_txrx_deinit(ol_txrx_soc_handle soc)
+{
+	struct dp_txrx_handle *dp_ext_hdl;
+	struct dp_soc *dp_soc;
+
+	if (!soc)
+		return QDF_STATUS_E_INVAL;
+
+	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
+	if (!dp_ext_hdl)
+		return QDF_STATUS_E_FAULT;
+
+	dp_soc = cdp_soc_t_to_dp_soc(soc);
+	if (wlan_cfg_is_rx_refill_buffer_pool_enabled(dp_soc->wlan_cfg_ctx)) {
+		dp_rx_refill_thread_deinit(&dp_ext_hdl->refill_thread);
+		dp_ext_hdl->refill_thread.soc = NULL;
+		dp_ext_hdl->refill_thread.enabled = false;
+	}
+
+	if (dp_ext_hdl->config.enable_rx_threads)
+		dp_rx_tm_deinit(&dp_ext_hdl->rx_tm_hdl);
+
+	qdf_mem_free(dp_ext_hdl);
+	dp_info("dp_txrx_handle_t de-allocated");
+
+	cdp_soc_set_dp_txrx_handle(soc, NULL);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * dp_rx_tm_get_pending() - get number of frame in thread
+ * nbuf queue pending
+ * @soc: ol_txrx_soc_handle object
+ *
+ * Return: number of frames
+ */
+#ifdef FEATURE_WLAN_DP_RX_THREADS
+int dp_rx_tm_get_pending(ol_txrx_soc_handle soc)
+{
+	int i;
+	int num_pending = 0;
+	struct dp_rx_thread *rx_thread;
+	struct dp_txrx_handle *dp_ext_hdl;
+	struct dp_rx_tm_handle *rx_tm_hdl;
+
+	if (!soc)
+		return 0;
+
+	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
+	if (!dp_ext_hdl)
+		return 0;
+
+	rx_tm_hdl = &dp_ext_hdl->rx_tm_hdl;
+
+	for (i = 0; i < rx_tm_hdl->num_dp_rx_threads; i++) {
+		rx_thread = rx_tm_hdl->rx_thread[i];
+		if (!rx_thread)
+			continue;
+		num_pending += qdf_nbuf_queue_head_qlen(&rx_thread->nbuf_queue);
+	}
+
+	if (num_pending)
+		dp_debug("pending frames in thread queue %d", num_pending);
+
+	return num_pending;
+}
+#else
+int dp_rx_tm_get_pending(ol_txrx_soc_handle soc)
+{
+	return 0;
+}
+#endif

components/dp/core/src/wlan_dp_softap_txrx.c

@@ -31,7 +31,7 @@
 #include <cdp_txrx_peer_ops.h>
 #include <cdp_txrx_misc.h>
 #include <cdp_txrx_flow_ctrl_v2.h>
-#include "dp_txrx.h"
+#include "wlan_dp_rx_thread.h"
 #include "nan_public_structs.h"
 #include "nan_ucfg_api.h"
 #include <wlan_cm_ucfg_api.h>
@@ -207,8 +207,8 @@ void dp_softap_check_wait_for_tx_eap_pkt(struct wlan_dp_intf *dp_intf,
 /**
  * dp_post_dhcp_ind() - Send DHCP START/STOP indication to FW
  * @dp_intf: pointer to DP interface
- * @sta_id: peer station ID
- * @type: WMA message type
+ * @mac_addr: mac address
+ * @dhcp_start: dhcp start
  *
  * Return: error number
  */
@@ -250,8 +250,8 @@ int dp_post_dhcp_ind(struct wlan_dp_intf *dp_intf, uint8_t *mac_addr,
 
 /**
  * dp_softap_notify_dhcp_ind() - Notify SAP for DHCP indication for tx desc
- * @context: pointer to DP interface context
- * @netbuf: pointer to OS packet (sk_buff)
+ * @intf_context: pointer to DP interface context
+ * @nbuf: pointer to OS packet (sk_buff)
  *
  * Return: None
  */
@@ -744,8 +744,8 @@ void dp_softap_tx_timeout(struct wlan_dp_intf *dp_intf)
 /**
  * dp_softap_notify_tx_compl_cbk() - callback to notify tx completion
  * @nbuf: pointer to n/w buffer
- * @dp_intf: pointer to DP interface
- * @flags: tx status flag
+ * @context: pointer to DP interface
+ * @flag: tx status flag
  *
  * Return: None
  */

components/dp/core/src/wlan_dp_txrx.c

@@ -30,7 +30,7 @@
 #include <cdp_txrx_peer_ops.h>
 #include <cdp_txrx_misc.h>
 #include <cdp_txrx_flow_ctrl_v2.h>
-#include "dp_txrx.h"
+#include "wlan_dp_rx_thread.h"
 #if defined(WLAN_SUPPORT_RX_FISA)
 #include "wlan_dp_fisa_rx.h"
 #endif
@@ -81,7 +81,6 @@ void dp_get_tx_resource(struct wlan_dp_intf *dp_intf,
  * dp_event_eapol_log() - send event to wlan diag
  * @nbuf: Network buffer ptr
  * @dir: direction
- * @eapol_key_info: eapol key info
  *
  * Return: None
  */
@@ -951,6 +950,7 @@ static void dp_resolve_rx_ol_mode(struct wlan_dp_psoc_context *dp_ctx)
 #ifdef WLAN_FEATURE_DYNAMIC_RX_AGGREGATION
 /**
  * dp_gro_rx_bh_disable() - GRO RX/flush function.
+ * @dp_intf: DP interface pointer
  * @napi_to_use: napi to be used to give packets to the stack, gro flush
  * @nbuf: pointer to n/w buff
  *
@@ -999,6 +999,7 @@ static QDF_STATUS dp_gro_rx_bh_disable(struct wlan_dp_intf *dp_intf,
 
 /**
  * dp_gro_rx_bh_disable() - GRO RX/flush function.
+ * @dp_intf: DP interface pointer
  * @napi_to_use: napi to be used to give packets to the stack, gro flush
  * @nbuf: pointer to nbuff
  *
@@ -1178,8 +1179,8 @@ out:
 }
 
 /**
- * dp_register_rx_ol() - Register LRO/GRO rx processing callbacks
- * @hdd_ctx: pointer to hdd_ctx
+ * dp_register_rx_ol_cb() - Register LRO/GRO rx processing callbacks
+ * @dp_ctx: pointer to dp_ctx
  * @wifi3_0_target: whether its a lithium/beryllium arch based target or not
  *
  * Return: none

components/dp/dispatcher/inc/wlan_dp_public_struct.h

@@ -33,6 +33,7 @@
 #include "cdp_txrx_ops.h"
 #include <qdf_defer.h>
 #include <qdf_types.h>
+#include "wlan_dp_rx_thread.h"
 
 #define DP_MAX_SUBTYPES_TRACKED	4
 
@@ -204,17 +205,18 @@ struct dp_dns_stats {
 /**
  * struct dp_tcp_stats - tcp debug stats count
  * @tx_tcp_syn_count: no. of tcp syn received from network stack
- * @@tx_tcp_ack_count: no. of tcp ack received from network stack
+ * @tx_tcp_ack_count: no. of tcp ack received from network stack
  * @rx_tcp_syn_ack_count: no. of tcp syn ack received from FW
  * @tx_tcp_syn_dropped: no. of tcp syn dropped at hdd layer
  * @tx_tcp_ack_dropped: no. of tcp ack dropped at hdd layer
  * @rx_delivered: no. of tcp syn ack delivered to network stack
  * @rx_refused: no of tcp syn ack refused (not delivered) to network stack
  * @tx_tcp_syn_host_fw_sent: no of tcp syn sent by FW OTA
- * @@tx_tcp_ack_host_fw_sent: no of tcp ack sent by FW OTA
+ * @tx_tcp_ack_host_fw_sent: no of tcp ack sent by FW OTA
  * @rx_host_drop: no of tcp syn ack dropped by host
+ * @rx_fw_cnt: no of tcp res received by FW
  * @tx_tcp_syn_ack_cnt: no of tcp syn acked by FW
- * @tx_tcp_syn_ack_cnt: no of tcp ack acked by FW
+ * @tx_tcp_ack_ack_cnt: no of tcp ack acked by FW
  * @is_tcp_syn_ack_rcv: flag to check tcp syn ack received or not
  * @is_tcp_ack_sent: flag to check tcp ack sent or not
  */
@@ -263,6 +265,7 @@ struct dp_icmpv4_stats {
 
 /**
  * struct dp_rsp_stats - arp packet stats
+ * @vdev_id: session id
  * @arp_req_enqueue: fw tx count
  * @arp_req_tx_success: tx ack count
  * @arp_req_tx_failure: tx ack fail count
@@ -351,7 +354,7 @@ struct dp_dhcp_ind {
 };
 
 /**
- * struct dp_mic_info - mic error info in dp
+ * struct dp_mic_error_info - mic error info in dp
  * @ta_mac_addr: transmitter mac address
  * @multicast: Flag for multicast
  * @key_id: Key ID
@@ -376,7 +379,7 @@ enum dp_mic_work_status {
 
 /**
  * struct dp_mic_work - mic work info in dp
- * @mic_error_work: mic error work
+ * @work: mic error work
  * @status: sattus of mic error work
  * @info: Pointer to mic error information
  * @lock: lock to synchronixe mic error work
@@ -402,6 +405,7 @@ enum dp_nud_state {
 	DP_NUD_STATE_INVALID
 };
 
+struct opaque_hdd_callback_handle;
 /**
  * typedef hdd_cb_handle - HDD Handle
  *
@@ -412,13 +416,11 @@ enum dp_nud_state {
  *
  * The HDD must be able to derive it's internal instance structure
  * pointer through this handle.
- */
-/*
+ *
  * NOTE WELL: struct opaque_hdd_callback_handle is not defined anywhere. This
  * reference is used to help ensure that a hdd_cb_handle is never used
  * where a different handle type is expected
  */
-struct opaque_hdd_callback_handle;
 typedef struct opaque_hdd_callback_handle *hdd_cb_handle;
 
 /**
@@ -432,6 +434,8 @@ typedef struct opaque_hdd_callback_handle *hdd_cb_handle;
  * @BUS_BW_LEVEL_5: vote for level-5 bus bandwidth
  * @BUS_BW_LEVEL_6: vote for level-6 bus bandwidth
  * @BUS_BW_LEVEL_7: vote for level-7 bus bandwidth
+ * @BUS_BW_LEVEL_8: vote for level-8 bus bandwidth
+ * @BUS_BW_LEVEL_MAX: vote for max level bus bandwidth
  */
 enum bus_bw_level {
 	BUS_BW_LEVEL_NONE,
@@ -459,6 +463,7 @@ enum bus_bw_level {
  * @TPUT_LEVEL_VERY_HIGH: very high throughput level
  * @TPUT_LEVEL_ULTRA_HIGH: ultra high throughput level
  * @TPUT_LEVEL_SUPER_HIGH: super high throughput level
+ * @TPUT_LEVEL_MAX: maximum throughput level
  */
 enum tput_level {
 	TPUT_LEVEL_NONE,
@@ -477,6 +482,7 @@ enum tput_level {
  *
  * @BBM_APPS_RESUME: system resume flag
  * @BBM_APPS_SUSPEND: system suspend flag
+ * @BBM_FLAG_MAX: maximum flag
  */
 enum bbm_non_per_flag {
 	BBM_APPS_RESUME,
@@ -496,6 +502,7 @@ enum bbm_non_per_flag {
  *  is set without taking other policy vote levels into consideration.
  * @BBM_SELECT_TABLE_POLICY: policy where bus bw table is selected based on
  *  the latency level.
+ * @BBM_MAX_POLICY: max policy
  */
 enum bbm_policy {
 	BBM_DRIVER_MODE_POLICY,
@@ -511,6 +518,7 @@ enum bbm_policy {
  *
  * @WLM_LL_NORMAL: normal latency level
  * @WLM_LL_LOW: low latency level
+ * @WLM_LL_MAX: max latency level
  */
 enum wlm_ll_level {
 	WLM_LL_NORMAL,
@@ -528,6 +536,7 @@ enum wlm_ll_level {
  * @wlm_level: latency level. valid for BBM_WLM_POLICY.
  * @user_level: user bus bandwidth vote. valid for BBM_USER_POLICY.
  * @set: set or reset user level. valid for BBM_USER_POLICY.
+ * @usr: user specific info
  */
 union bbm_policy_info {
 	enum QDF_GLOBAL_MODE driver_mode;
@@ -541,7 +550,7 @@ union bbm_policy_info {
 };
 
 /**
- * struct bbm_params - BBM params
+ * struct bbm_params: BBM params
  *
  * @policy: BBM policy
  * @policy_info: policy related info
@@ -552,7 +561,9 @@ struct bbm_params {
 };
 
 /**
- * wlan_tp_data : union of TCP msg for Tx and Rx Dir
+ * union wlan_tp_data: union of TCP msg for Tx and Rx Dir
+ * @tx_tp_data: msg to TCP for Tx Dir
+ * @rx_tp_data: msg to TCP for Rx Dir
  */
 union wlan_tp_data {
 	struct wlan_tx_tp_data tx_tp_data;
@@ -564,6 +575,24 @@ union wlan_tp_data {
  * to non-converged driver
  * @callback_ctx : Opaque callback context
  * @dp_get_netdev_by_vdev_mac: Callback to get netdev from vdev mac address
+ * @dp_get_tx_flow_low_watermark: Callback to get TX flow low watermark info
+ * @dp_get_tx_resource: Callback to check tx resources and take action
+ * @dp_get_tsf_time: Callback to get TSF time
+ * @dp_tsf_timestamp_rx: Callback to set rx packet timestamp
+ * @dp_nbuf_push_pkt: Callback to push rx pkt to network
+ * @dp_rx_napi_gro_flush: OS IF Callback to GRO RX/flush function.
+ * @dp_rx_thread_napi_gro_flush: OS IF Callback to do gro flush
+ * @dp_rx_napi_gro_receive: OS IF Callback for GRO RX receive function.
+ * @dp_lro_rx_cb: OS IF Callback for LRO receive function
+ * @dp_gro_rx_legacy_get_napi: Callback to get napi in legacy gro case
+ * @dp_register_rx_offld_flush_cb: OS IF Callback to get rx offld flush cb
+ * @dp_rx_check_qdisc_configured: OS IF Callback to check if any ingress qdisc
+ * configured
+ * @dp_is_gratuitous_arp_unsolicited_na: OS IF Callback to check gratuitous arp
+ * unsolicited na
+ * @dp_send_rx_pkt_over_nl: OS IF Callback to send rx pkt over nl
+ * @dp_disable_rx_ol_for_low_tput: Callback to disable Rx offload in low TPUT
+ * scenario
  * @wlan_dp_sta_get_dot11mode: Callback to get dot11 mode
  * @wlan_dp_get_ap_client_count: Callback to get client count connected to AP
  * @wlan_dp_sta_ndi_connected: Callback to get NDI connected status
@@ -581,7 +610,8 @@ union wlan_tp_data {
  * @dp_is_ap_active:Callback to check if AP is active
  * @dp_napi_apply_throughput_policy:Callback to apply NAPI throughput policy
  * @wlan_dp_display_tx_multiq_stats: Callback to display Tx Mulit queue stats
- * @wlan_dp_display_netif_queue_history: Callback to display Netif queue history
+ * @wlan_dp_display_netif_queue_history: Callback to display Netif queue
+ * history
  * @osif_dp_process_mic_error: osif callback to process MIC error
  * @dp_is_link_adapter: Callback API to check if adapter is link adapter
  * @os_if_dp_nud_stats_info: osif callback to print nud stats info
@@ -607,6 +637,9 @@ struct wlan_dp_psoc_callbacks {
 	QDF_STATUS (*dp_rx_napi_gro_flush)(qdf_napi_struct *napi_to_use,
 					   qdf_nbuf_t nbuf,
 					   uint8_t *force_flush);
+	void
+	(*dp_rx_thread_napi_gro_flush)(qdf_napi_struct *napi,
+				       enum dp_rx_gro_flush_code flush_code);
 	QDF_STATUS (*dp_rx_napi_gro_receive)(qdf_napi_struct *napi_to_use,
 					     qdf_nbuf_t nbuf);
 
@@ -714,6 +747,7 @@ struct wlan_dp_psoc_nb_ops {
 /**
  * struct wlan_dp_user_config - DP component user config
  * @ipa_enable: IPA enabled/disabled config
+ * @arp_connectivity_map: ARP connectiviy map
  */
 struct wlan_dp_user_config {
 	bool ipa_enable;

components/dp/dispatcher/inc/wlan_dp_ucfg_api.h

@@ -53,7 +53,7 @@ ucfg_dp_is_roam_after_nud_enabled(struct wlan_objmgr_psoc *psoc)
 #endif
 
 /**
- * ucfg_dp_create_intf() - update DP interface MAC address
+ * ucfg_dp_update_inf_mac() - update DP interface MAC address
  * @psoc: psoc handle
  * @cur_mac: Current MAC address
  * @new_mac: new MAC address
@@ -180,7 +180,7 @@ void ucfg_dp_conn_info_set_arp_service(struct wlan_objmgr_vdev *vdev,
 /**
  * ucfg_dp_conn_info_set_peer_authenticate() - set Peer authenticated state
  * @vdev: vdev mapped to STA DP interface
- * is_authenticated: Peer authenticated info
+ * @is_authenticated: Peer authenticated info
  *
  * Return: None
  */
@@ -190,7 +190,7 @@ void ucfg_dp_conn_info_set_peer_authenticate(struct wlan_objmgr_vdev *vdev,
 /**
  * ucfg_dp_conn_info_set_peer_mac() - set peer mac info in DP intf
  * @vdev: vdev mapped to STA DP interface
- * peer_mac: Peer MAC information
+ * @peer_mac: Peer MAC information
  *
  * Return: None
  */
@@ -200,7 +200,7 @@ void ucfg_dp_conn_info_set_peer_mac(struct wlan_objmgr_vdev *vdev,
 /**
  * ucfg_dp_softap_check_wait_for_tx_eap_pkt() - wait for TX EAP pkt in SAP
  * @vdev: vdev mapped to SAP DP interface
- * mac_addr: Peer MAC address info
+ * @mac_addr: Peer MAC address info
  *
  * Return: None
  */
@@ -210,7 +210,7 @@ void ucfg_dp_softap_check_wait_for_tx_eap_pkt(struct wlan_objmgr_vdev *vdev,
 /**
  * ucfg_dp_update_dhcp_state_on_disassoc() - update DHCP during disassoc
  * @vdev: vdev mapped to SAP DP interface
- * mac_addr: Peer MAC address info
+ * @mac_addr: Peer MAC address info
  *
  * Return: None
  */
@@ -220,7 +220,7 @@ void ucfg_dp_update_dhcp_state_on_disassoc(struct wlan_objmgr_vdev *vdev,
 /**
  * ucfg_dp_set_dfs_cac_tx() - update DFS CAC TX block info
  * @vdev: vdev mapped to SAP DP interface
- * tx_block: true if TX need to be blocked
+ * @tx_block: true if TX need to be blocked
  *
  * Return: None
  */
@@ -230,7 +230,7 @@ void ucfg_dp_set_dfs_cac_tx(struct wlan_objmgr_vdev *vdev,
 /**
  * ucfg_dp_set_bss_state_start() - update BSS state for SAP intf
  * @vdev: vdev mapped to SAP DP interface
- * start: true if BSS state is started
+ * @start: true if BSS state is started
  *
  * Return: None
  */
@@ -239,7 +239,7 @@ void ucfg_dp_set_bss_state_start(struct wlan_objmgr_vdev *vdev, bool start);
 /**
  * ucfg_dp_lro_set_reset() - LRO set/reset in DP
  * @vdev: vdev mapped to DP interface
- * enable_flag: Enable/disable LRO feature
+ * @enable_flag: Enable/disable LRO feature
  *
  * Return: 0 on success and non zero on failure.
  */
@@ -288,6 +288,7 @@ bool ucfg_dp_is_rx_threads_enabled(struct wlan_objmgr_psoc *psoc);
 /**
  * ucfg_dp_rx_ol_init() - Initialize Rx offload mode (LRO or GRO)
  * @psoc: PSOC mapped to DP context
+ * @is_wifi3_0_target: true if it wifi3.0 target
  *
  * Return: 0 on success and non zero on failure.
  */
@@ -383,7 +384,8 @@ qdf_net_dev_stats *ucfg_dp_get_dev_stats(qdf_netdev_t dev);
 /**
  * ucfg_dp_inc_rx_pkt_stats() - DP increment RX pkt stats
  * @vdev: VDEV mapped to DP interface
- * pkt_len: packet length to be incremented in stats
+ * @pkt_len: packet length to be incremented in stats
+ * @delivered: pkts delivered or not
  *
  * Return: None
  */
@@ -457,6 +459,7 @@ QDF_STATUS ucfg_dp_mon_register_txrx_ops(struct wlan_objmgr_vdev *vdev)
 /**
  * ucfg_dp_softap_register_txrx_ops() - Register ops for TX/RX operations
  * @vdev: vdev mapped to SAP mode DP interface
+ * @txrx_ops: Tx and Rx data transfer ops
  *
  * Return: 0 on success and non zero on failure.
  */
@@ -504,7 +507,7 @@ void ucfg_dp_bbm_apply_independent_policy(struct wlan_objmgr_psoc *psoc,
 
 /**
  * ucfg_dp_periodic_sta_stats_start() - Start displaying periodic stats for STA
- * @adapter: Pointer to the station adapter
+ * @vdev: Pointer to the vdev
  *
  * Return: none
  */
@@ -512,7 +515,7 @@ void ucfg_dp_periodic_sta_stats_start(struct wlan_objmgr_vdev *vdev);
 
 /**
  * ucfg_dp_periodic_sta_stats_stop() - Stop displaying periodic stats for STA
- * @adapter: Pointer to the station adapter
+ * @vdev: Pointer to the vdev
  *
  * Return: none
  */
@@ -542,8 +545,7 @@ void ucfg_dp_try_send_rps_ind(struct wlan_objmgr_vdev *vdev);
 
 /**
  * ucfg_dp_reg_ipa_rsp_ind() - Resiter RSP IND cb with IPA component
- * @psoc: psoc handle
- * @cb_obj: Callback object
+ * @pdev: pdev handle
  *
  * Returns: None
  */
@@ -710,7 +712,7 @@ void ucfg_dp_nud_set_gateway_addr(struct wlan_objmgr_vdev *vdev,
 
 /**
  * ucfg_dp_nud_event() - netevent callback
- * @netdev_addr: netdev_addr
+ * @netdev_mac_addr: netdev MAC addr
  * @gw_mac_addr: Gateway MAC address
  * @nud_state : NUD State
  *
@@ -809,6 +811,7 @@ void ucfg_dp_clear_dns_payload_value(struct wlan_objmgr_vdev *vdev);
 /**
  * ucfg_dp_set_pkt_type_bitmap_value() - Set Packet type bitmap value
  * @vdev: vdev context
+ * @value: bitmap value
  *
  * Return: None
  */
@@ -826,6 +829,7 @@ uint32_t ucfg_dp_intf_get_pkt_type_bitmap_value(void *intf_ctx);
 /**
  * ucfg_dp_set_track_dest_ipv4_value() - Set track_dest_ipv4 value
  * @vdev: vdev context
+ * @value: dest ipv4 value
  *
  * Return: None
  */
@@ -835,6 +839,7 @@ void ucfg_dp_set_track_dest_ipv4_value(struct wlan_objmgr_vdev *vdev,
 /**
  * ucfg_dp_set_track_dest_port_value() - Set track_dest_port value
  * @vdev: vdev context
+ * @value: dest port value
  *
  * Return: None
  */
@@ -844,6 +849,7 @@ void ucfg_dp_set_track_dest_port_value(struct wlan_objmgr_vdev *vdev,
 /**
  * ucfg_dp_set_track_src_port_value() - Set track_dest_port value
  * @vdev: vdev context
+ * @value: src port value
  *
  * Return: None
  */
@@ -853,6 +859,7 @@ void ucfg_dp_set_track_src_port_value(struct wlan_objmgr_vdev *vdev,
 /**
  * ucfg_dp_set_track_dns_domain_len_value() - Set track_dns_domain_len value
  * @vdev: vdev context
+ * @value: dns domain len value
  *
  * Return: None
  */
@@ -862,6 +869,7 @@ void ucfg_dp_set_track_dns_domain_len_value(struct wlan_objmgr_vdev *vdev,
 /**
  * ucfg_dp_set_track_arp_ip_value() - Set track_arp_ip value
  * @vdev: vdev context
+ * @value: ARP IP value
  *
  * Return: None
  */
@@ -880,6 +888,7 @@ uint32_t ucfg_dp_get_pkt_type_bitmap_value(struct wlan_objmgr_vdev *vdev);
  * ucfg_dp_get_dns_payload_value() - Get dns_payload value
  * @vdev: vdev context
  * @dns_query : DNS query pointer
+ *
  * Return: None
  */
 void ucfg_dp_get_dns_payload_value(struct wlan_objmgr_vdev *vdev,
@@ -1150,7 +1159,7 @@ void ucfg_dp_set_tc_based_dyn_gro(struct wlan_objmgr_psoc *psoc, bool value);
 
 /**
  * ucfg_dp_runtime_disable_rx_thread() - Disable rx thread
- * @psoc: psoc handle
+ * @vdev: vdev handle
  * @value : value to be set (true/false)
  *
  * Return: None
@@ -1203,7 +1212,6 @@ uint32_t ucfg_dp_get_bus_bw_high_threshold(struct wlan_objmgr_psoc *psoc);
  * ucfg_dp_event_eapol_log() - send event to wlan diag
  * @nbuf: Network buffer ptr
  * @dir: direction
- * @eapol_key_info: eapol key info
  *
  * Return: None
  */
@@ -1448,4 +1456,43 @@ QDF_STATUS ucfg_dp_config_direct_link(struct wlan_objmgr_vdev *vdev,
 	return QDF_STATUS_SUCCESS;
 }
 #endif
-#endif /* _WLAN_DP_UCFG_API_H_ */
+
+/**
+ * ucfg_dp_txrx_init() - initialize DP TXRX module
+ * @soc: ol_txrx_soc_handle
+ * @pdev_id: id of dp pdev handle
+ * @config: configuration for DP TXRX modules
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
+ */
+QDF_STATUS ucfg_dp_txrx_init(ol_txrx_soc_handle soc, uint8_t pdev_id,
+			     struct dp_txrx_config *config);
+
+/**
+ * ucfg_dp_txrx_deinit() - de-initialize DP TXRX module
+ * @soc: ol_txrx_soc_handle
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
+ */
+QDF_STATUS ucfg_dp_txrx_deinit(ol_txrx_soc_handle soc);
+
+/**
+ * ucfg_dp_txrx_ext_dump_stats() - dump txrx external module stats
+ * @soc: ol_txrx_soc_handle object
+ * @stats_id: id  for the module whose stats are needed
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
+ */
+QDF_STATUS ucfg_dp_txrx_ext_dump_stats(ol_txrx_soc_handle soc,
+				       uint8_t stats_id);
+/**
+ * ucfg_dp_txrx_set_cpu_mask() - set CPU mask for RX threads
+ * @soc: ol_txrx_soc_handle object
+ * @new_mask: New CPU mask pointer
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
+ */
+QDF_STATUS ucfg_dp_txrx_set_cpu_mask(ol_txrx_soc_handle soc,
+				     qdf_cpu_mask *new_mask);
+
+#endif /* _WLAN_DP_UCFGi_API_H_ */

components/dp/dispatcher/src/wlan_dp_ucfg_api.c

@@ -38,6 +38,7 @@
 #include <cdp_txrx_ctrl.h>
 #include <qdf_net_stats.h>
 #include "wlan_dp_prealloc.h"
+#include "wlan_dp_rx_thread.h"
 
 void ucfg_dp_update_inf_mac(struct wlan_objmgr_psoc *psoc,
 			    struct qdf_mac_addr *cur_mac,
@@ -330,7 +331,7 @@ ucfg_dp_suspend_handler(struct wlan_objmgr_psoc *psoc, void *arg)
 	struct wlan_dp_psoc_context *dp_ctx;
 	struct wlan_dp_intf *dp_intf, *dp_intf_next = NULL;
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
-
+	QDF_STATUS status;
 	dp_ctx = dp_psoc_get_priv(psoc);
 	if (!dp_ctx) {
 		dp_err("DP context not found");
@@ -342,6 +343,15 @@ ucfg_dp_suspend_handler(struct wlan_objmgr_psoc *psoc, void *arg)
 	dp_for_each_intf_held_safe(dp_ctx, dp_intf, dp_intf_next) {
 		dp_intf->sap_tx_block_mask |= WLAN_DP_SUSPEND;
 	}
+	if (dp_ctx->enable_dp_rx_threads) {
+		status = dp_txrx_suspend(cds_get_context(QDF_MODULE_ID_SOC));
+
+		if (status != QDF_STATUS_SUCCESS) {
+			dp_intf->sap_tx_block_mask &= ~WLAN_DP_SUSPEND;
+			dp_txrx_resume(cds_get_context(QDF_MODULE_ID_SOC));
+			return status;
+			}
+	}
 	return QDF_STATUS_SUCCESS;
 }
 
@@ -372,6 +382,8 @@ ucfg_dp_resume_handler(struct wlan_objmgr_psoc *psoc, void *arg)
 	dp_for_each_intf_held_safe(dp_ctx, dp_intf, dp_intf_next) {
 		dp_intf->sap_tx_block_mask &= ~WLAN_DP_SUSPEND;
 	}
+	if (dp_ctx->enable_dp_rx_threads)
+		dp_txrx_resume(cds_get_context(QDF_MODULE_ID_SOC));
 	return QDF_STATUS_SUCCESS;
 }
 
@@ -885,8 +897,6 @@ ucfg_dp_get_rx_softirq_yield_duration(struct wlan_objmgr_psoc *psoc)
 /**
  * dp_rx_register_fisa_ops() - FISA callback functions
  * @txrx_ops: operations handle holding callback functions
- * @dp_rx_fisa_cbk: callback for fisa aggregation handle function
- * @dp_rx_fisa_flush: callback function to flush fisa aggregation
  *
  * Return: None
  */
@@ -1931,6 +1941,8 @@ void ucfg_dp_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc,
 
 	dp_ctx->dp_ops.dp_nbuf_push_pkt = cb_obj->dp_nbuf_push_pkt;
 	dp_ctx->dp_ops.dp_rx_napi_gro_flush = cb_obj->dp_rx_napi_gro_flush;
+	dp_ctx->dp_ops.dp_rx_thread_napi_gro_flush =
+	    cb_obj->dp_rx_thread_napi_gro_flush;
 	dp_ctx->dp_ops.dp_rx_napi_gro_receive = cb_obj->dp_rx_napi_gro_receive;
 	dp_ctx->dp_ops.dp_lro_rx_cb = cb_obj->dp_lro_rx_cb;
 	dp_ctx->dp_ops.dp_register_rx_offld_flush_cb =
@@ -2391,3 +2403,26 @@ QDF_STATUS ucfg_dp_config_direct_link(struct wlan_objmgr_vdev *vdev,
 				     enable_low_latency);
 }
 #endif
+
+QDF_STATUS ucfg_dp_txrx_init(ol_txrx_soc_handle soc, uint8_t pdev_id,
+			     struct dp_txrx_config *config)
+{
+	return dp_txrx_init(soc, pdev_id, config);
+}
+
+QDF_STATUS ucfg_dp_txrx_deinit(ol_txrx_soc_handle soc)
+{
+	return dp_txrx_deinit(soc);
+}
+
+QDF_STATUS ucfg_dp_txrx_ext_dump_stats(ol_txrx_soc_handle soc,
+				       uint8_t stats_id)
+{
+	return dp_txrx_ext_dump_stats(soc, stats_id);
+}
+
+QDF_STATUS ucfg_dp_txrx_set_cpu_mask(ol_txrx_soc_handle soc,
+				     qdf_cpu_mask *new_mask)
+{
+	return dp_txrx_set_cpu_mask(soc, new_mask);
+}

core/dp/txrx3.0/dp_txrx.c

@@ -1,204 +0,0 @@
-/*
- * Copyright (c) 2017-2021 The Linux Foundation. All rights reserved.
- * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
- *
- * Permission to use, copy, modify, and/or distribute this software for
- * any purpose with or without fee is hereby granted, provided that the
- * above copyright notice and this permission notice appear in all
- * copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
- * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
- * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
- * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
- * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include <wlan_objmgr_pdev_obj.h>
-#include <dp_txrx.h>
-#include <dp_types.h>
-#include <dp_internal.h>
-#include <cdp_txrx_cmn.h>
-#include <cdp_txrx_misc.h>
-#include <dp_tx_desc.h>
-#include <dp_rx.h>
-#include <ce_api.h>
-#include <ce_internal.h>
-#include <wlan_cfg.h>
-
-/**
- * dp_rx_refill_thread_schedule() - Schedule rx refill thread
- * @soc: ol_txrx_soc_handle object
- *
- */
-#ifdef WLAN_FEATURE_RX_PREALLOC_BUFFER_POOL
-static void dp_rx_refill_thread_schedule(ol_txrx_soc_handle soc)
-{
-	struct dp_rx_refill_thread *rx_thread;
-	struct dp_txrx_handle *dp_ext_hdl;
-
-	if (!soc)
-		return;
-
-	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
-	if (!dp_ext_hdl)
-		return;
-
-	rx_thread = &dp_ext_hdl->refill_thread;
-	qdf_set_bit(RX_REFILL_POST_EVENT, &rx_thread->event_flag);
-	qdf_wake_up_interruptible(&rx_thread->wait_q);
-}
-#else
-static void dp_rx_refill_thread_schedule(ol_txrx_soc_handle soc)
-{
-}
-#endif
-
-/**
- * dp_get_rx_threads_num() - Get number of threads in use
- * @soc: ol_txrx_soc_handle object
- *
- * Return: number of threads
- */
-static uint8_t dp_get_rx_threads_num(ol_txrx_soc_handle soc)
-{
-	return cdp_get_num_rx_contexts(soc);
-}
-
-QDF_STATUS dp_txrx_init(ol_txrx_soc_handle soc, uint8_t pdev_id,
-			struct dp_txrx_config *config)
-{
-	struct dp_txrx_handle *dp_ext_hdl;
-	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
-	uint8_t num_dp_rx_threads;
-	struct dp_pdev *pdev;
-	struct dp_soc *dp_soc;
-
-	if (qdf_unlikely(!soc)) {
-		dp_err("soc is NULL");
-		return 0;
-	}
-
-	pdev = dp_get_pdev_from_soc_pdev_id_wifi3(cdp_soc_t_to_dp_soc(soc),
-						  pdev_id);
-	if (!pdev) {
-		dp_err("pdev is NULL");
-		return 0;
-	}
-
-	dp_ext_hdl = qdf_mem_malloc(sizeof(*dp_ext_hdl));
-	if (!dp_ext_hdl) {
-		QDF_ASSERT(0);
-		return QDF_STATUS_E_NOMEM;
-	}
-
-	dp_info("dp_txrx_handle allocated");
-	dp_ext_hdl->soc = soc;
-	dp_ext_hdl->pdev = dp_pdev_to_cdp_pdev(pdev);
-	cdp_soc_set_dp_txrx_handle(soc, dp_ext_hdl);
-	qdf_mem_copy(&dp_ext_hdl->config, config, sizeof(*config));
-	dp_ext_hdl->rx_tm_hdl.txrx_handle_cmn =
-				dp_txrx_get_cmn_hdl_frm_ext_hdl(dp_ext_hdl);
-
-	dp_soc = cdp_soc_t_to_dp_soc(soc);
-	if (wlan_cfg_is_rx_refill_buffer_pool_enabled(dp_soc->wlan_cfg_ctx)) {
-		dp_ext_hdl->refill_thread.soc = soc;
-		dp_ext_hdl->refill_thread.enabled = true;
-		qdf_status =
-			dp_rx_refill_thread_init(&dp_ext_hdl->refill_thread);
-		if (qdf_status != QDF_STATUS_SUCCESS) {
-			dp_err("Failed to initialize RX refill thread status:%d",
-			       qdf_status);
-			return qdf_status;
-		}
-		cdp_register_rx_refill_thread_sched_handler(soc,
-						dp_rx_refill_thread_schedule);
-	}
-
-	num_dp_rx_threads = dp_get_rx_threads_num(soc);
-	dp_info("%d RX threads in use", num_dp_rx_threads);
-
-	if (dp_ext_hdl->config.enable_rx_threads) {
-		qdf_status = dp_rx_tm_init(&dp_ext_hdl->rx_tm_hdl,
-					   num_dp_rx_threads);
-	}
-
-	return qdf_status;
-}
-
-QDF_STATUS dp_txrx_deinit(ol_txrx_soc_handle soc)
-{
-	struct dp_txrx_handle *dp_ext_hdl;
-	struct dp_soc *dp_soc;
-
-	if (!soc)
-		return QDF_STATUS_E_INVAL;
-
-	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
-	if (!dp_ext_hdl)
-		return QDF_STATUS_E_FAULT;
-
-	dp_soc = cdp_soc_t_to_dp_soc(soc);
-	if (wlan_cfg_is_rx_refill_buffer_pool_enabled(dp_soc->wlan_cfg_ctx)) {
-		dp_rx_refill_thread_deinit(&dp_ext_hdl->refill_thread);
-		dp_ext_hdl->refill_thread.soc = NULL;
-		dp_ext_hdl->refill_thread.enabled = false;
-	}
-
-	if (dp_ext_hdl->config.enable_rx_threads)
-		dp_rx_tm_deinit(&dp_ext_hdl->rx_tm_hdl);
-
-	qdf_mem_free(dp_ext_hdl);
-	dp_info("dp_txrx_handle_t de-allocated");
-
-	cdp_soc_set_dp_txrx_handle(soc, NULL);
-
-	return QDF_STATUS_SUCCESS;
-}
-
-/**
- * dp_rx_tm_get_pending() - get number of frame in thread
- * nbuf queue pending
- * @soc: ol_txrx_soc_handle object
- *
- * Return: number of frames
- */
-#ifdef FEATURE_WLAN_DP_RX_THREADS
-int dp_rx_tm_get_pending(ol_txrx_soc_handle soc)
-{
-	int i;
-	int num_pending = 0;
-	struct dp_rx_thread *rx_thread;
-	struct dp_txrx_handle *dp_ext_hdl;
-	struct dp_rx_tm_handle *rx_tm_hdl;
-
-	if (!soc)
-		return 0;
-
-	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
-	if (!dp_ext_hdl)
-		return 0;
-
-	rx_tm_hdl = &dp_ext_hdl->rx_tm_hdl;
-
-	for (i = 0; i < rx_tm_hdl->num_dp_rx_threads; i++) {
-		rx_thread = rx_tm_hdl->rx_thread[i];
-		if (!rx_thread)
-			continue;
-		num_pending += qdf_nbuf_queue_head_qlen(&rx_thread->nbuf_queue);
-	}
-
-	if (num_pending)
-		dp_debug("pending frames in thread queue %d", num_pending);
-
-	return num_pending;
-}
-#else
-int dp_rx_tm_get_pending(ol_txrx_soc_handle soc)
-{
-	return 0;
-}
-#endif

core/dp/txrx3.0/dp_txrx.h

@@ -1,485 +0,0 @@
-/*
- * Copyright (c) 2017-2021 The Linux Foundation. All rights reserved.
- * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved.
- *
- * Permission to use, copy, modify, and/or distribute this software for
- * any purpose with or without fee is hereby granted, provided that the
- * above copyright notice and this permission notice appear in all
- * copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
- * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
- * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
- * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
- * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef _DP_TXRX_H
-#define _DP_TXRX_H
-
-#include <wlan_objmgr_psoc_obj.h>
-#include <dp_rx_thread.h>
-#include <qdf_trace.h>
-#include <cdp_txrx_cmn_struct.h>
-#include <cdp_txrx_cmn.h>
-
-/**
- * struct dp_txrx_config - dp txrx configuration passed to dp txrx modules
- * @enable_dp_rx_threads: enable DP rx threads or not
- */
-struct dp_txrx_config {
-	bool enable_rx_threads;
-};
-
-struct dp_txrx_handle_cmn;
-/**
- * struct dp_txrx_handle - main dp txrx container handle
- * @soc: ol_txrx_soc_handle soc handle
- * @refill_thread: rx refill thread infra handle
- * @rx_tm_hdl: rx thread infrastructure handle
- */
-struct dp_txrx_handle {
-	ol_txrx_soc_handle soc;
-	struct cdp_pdev *pdev;
-	struct dp_rx_tm_handle rx_tm_hdl;
-	struct dp_rx_refill_thread refill_thread;
-	struct dp_txrx_config config;
-};
-
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 0))
-/**
- * dp_rx_napi_gro_flush() - do gro flush
- * @napi: napi used to do gro flush
- * @flush_code: flush_code differentiating low_tput_flush and normal_flush
- *
- * if there is RX GRO_NORMAL packets pending in napi
- * rx_list, flush them manually right after napi_gro_flush.
- *
- * return: none
- */
-static inline void dp_rx_napi_gro_flush(struct napi_struct *napi,
-					enum dp_rx_gro_flush_code flush_code)
-{
-	if (napi->poll) {
-		/* Skipping GRO flush in low TPUT */
-		if (flush_code != DP_RX_GRO_LOW_TPUT_FLUSH)
-			napi_gro_flush(napi, false);
-
-		if (napi->rx_count) {
-			netif_receive_skb_list(&napi->rx_list);
-			qdf_init_list_head(&napi->rx_list);
-			napi->rx_count = 0;
-		}
-	}
-}
-#else
-static inline void dp_rx_napi_gro_flush(struct napi_struct *napi,
-					enum dp_rx_gro_flush_code flush_code)
-{
-	if (napi->poll) {
-		/* Skipping GRO flush in low TPUT */
-		if (flush_code != DP_RX_GRO_LOW_TPUT_FLUSH)
-			napi_gro_flush(napi, false);
-	}
-}
-#endif
-
-#ifdef FEATURE_WLAN_DP_RX_THREADS
-/**
- * dp_txrx_get_cmn_hdl_frm_ext_hdl() - conversion func ext_hdl->txrx_handle_cmn
- * @dp_ext_hdl: pointer to dp_txrx_handle structure
- *
- * Return: typecasted pointer of type - struct dp_txrx_handle_cmn
- */
-static inline struct dp_txrx_handle_cmn *
-dp_txrx_get_cmn_hdl_frm_ext_hdl(struct dp_txrx_handle *dp_ext_hdl)
-{
-	return (struct dp_txrx_handle_cmn *)dp_ext_hdl;
-}
-
-/**
- * dp_txrx_get_ext_hdl_frm_cmn_hdl() - conversion func txrx_handle_cmn->ext_hdl
- * @txrx_cmn_hdl: pointer to dp_txrx_handle_cmn structure
- *
- * Return: typecasted pointer of type - struct dp_txrx_handle
- */
-static inline struct dp_txrx_handle *
-dp_txrx_get_ext_hdl_frm_cmn_hdl(struct dp_txrx_handle_cmn *txrx_cmn_hdl)
-{
-	return (struct dp_txrx_handle *)txrx_cmn_hdl;
-}
-
-static inline ol_txrx_soc_handle
-dp_txrx_get_soc_from_ext_handle(struct dp_txrx_handle_cmn *txrx_cmn_hdl)
-{
-	struct dp_txrx_handle *dp_ext_hdl;
-
-	dp_ext_hdl = dp_txrx_get_ext_hdl_frm_cmn_hdl(txrx_cmn_hdl);
-
-	return dp_ext_hdl->soc;
-}
-
-static inline struct cdp_pdev*
-dp_txrx_get_pdev_from_ext_handle(struct dp_txrx_handle_cmn *txrx_cmn_hdl)
-{
-	struct dp_txrx_handle *dp_ext_hdl;
-
-	dp_ext_hdl = dp_txrx_get_ext_hdl_frm_cmn_hdl(txrx_cmn_hdl);
-
-	return dp_ext_hdl->pdev;
-}
-
-/**
- * dp_txrx_init() - initialize DP TXRX module
- * @soc: ol_txrx_soc_handle
- * @pdev_id: id of dp pdev handle
- * @config: configuration for DP TXRX modules
- *
- * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
- */
-QDF_STATUS dp_txrx_init(ol_txrx_soc_handle soc, uint8_t pdev_id,
-			struct dp_txrx_config *config);
-
-/**
- * dp_txrx_deinit() - de-initialize DP TXRX module
- * @soc: ol_txrx_soc_handle
- *
- * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
- */
-QDF_STATUS dp_txrx_deinit(ol_txrx_soc_handle soc);
-
-/**
- * dp_txrx_flush_pkts_by_vdev_id() - flush rx packets for a vdev_id
- * @soc: ol_txrx_soc_handle object
- * @vdev_id: vdev_id for which rx packets are to be flushed
- *
- * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
- */
-static inline QDF_STATUS dp_txrx_flush_pkts_by_vdev_id(ol_txrx_soc_handle soc,
-						       uint8_t vdev_id)
-{
-	struct dp_txrx_handle *dp_ext_hdl;
-	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
-
-	if (!soc) {
-		qdf_status = QDF_STATUS_E_INVAL;
-		goto ret;
-	}
-
-	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
-	if (!dp_ext_hdl) {
-		qdf_status = QDF_STATUS_E_FAULT;
-		goto ret;
-	}
-
-	qdf_status = dp_rx_tm_flush_by_vdev_id(&dp_ext_hdl->rx_tm_hdl, vdev_id);
-ret:
-	return qdf_status;
-}
-
-/**
- * dp_txrx_resume() - resume all threads
- * @soc: ol_txrx_soc_handle object
- *
- * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
- */
-static inline QDF_STATUS dp_txrx_resume(ol_txrx_soc_handle soc)
-{
-	struct dp_txrx_handle *dp_ext_hdl;
-	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
-	struct dp_rx_refill_thread *refill_thread;
-
-	if (!soc) {
-		qdf_status = QDF_STATUS_E_INVAL;
-		goto ret;
-	}
-
-	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
-	if (!dp_ext_hdl) {
-		qdf_status = QDF_STATUS_E_FAULT;
-		goto ret;
-	}
-
-	refill_thread = &dp_ext_hdl->refill_thread;
-	if (refill_thread->enabled) {
-		qdf_status = dp_rx_refill_thread_resume(refill_thread);
-		if (qdf_status != QDF_STATUS_SUCCESS)
-			return qdf_status;
-	}
-
-	qdf_status = dp_rx_tm_resume(&dp_ext_hdl->rx_tm_hdl);
-ret:
-	return qdf_status;
-}
-
-/**
- * dp_txrx_suspend() - suspend all threads
- * @soc: ol_txrx_soc_handle object
- *
- * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
- */
-static inline QDF_STATUS dp_txrx_suspend(ol_txrx_soc_handle soc)
-{
-	struct dp_txrx_handle *dp_ext_hdl;
-	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
-	struct dp_rx_refill_thread *refill_thread;
-
-	if (!soc) {
-		qdf_status = QDF_STATUS_E_INVAL;
-		goto ret;
-	}
-
-	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
-	if (!dp_ext_hdl) {
-		qdf_status = QDF_STATUS_E_FAULT;
-		goto ret;
-	}
-
-	refill_thread = &dp_ext_hdl->refill_thread;
-	if (refill_thread->enabled) {
-		qdf_status = dp_rx_refill_thread_suspend(refill_thread);
-		if (qdf_status != QDF_STATUS_SUCCESS)
-			return qdf_status;
-	}
-
-	qdf_status = dp_rx_tm_suspend(&dp_ext_hdl->rx_tm_hdl);
-	if (QDF_IS_STATUS_ERROR(qdf_status) && refill_thread->enabled)
-		dp_rx_refill_thread_resume(refill_thread);
-
-ret:
-	return qdf_status;
-}
-
-/**
- * dp_rx_enqueue_pkt() - enqueue packet(s) into the thread
- * @soc: ol_txrx_soc_handle object
- * @nbuf_list: list of packets to be queued into the rx_thread
- *
- * The function accepts a list of skbs connected by the skb->next pointer and
- * queues them into a RX thread to be sent to the stack.
- *
- * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
- */
-static inline
-QDF_STATUS dp_rx_enqueue_pkt(ol_txrx_soc_handle soc, qdf_nbuf_t nbuf_list)
-{
-	struct dp_txrx_handle *dp_ext_hdl;
-	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
-
-	if (!soc || !nbuf_list) {
-		qdf_status = QDF_STATUS_E_INVAL;
-		dp_err("invalid input params soc %pK nbuf %pK"
-		       , soc, nbuf_list);
-		goto ret;
-	}
-
-	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
-	if (!dp_ext_hdl) {
-		qdf_status = QDF_STATUS_E_FAULT;
-		goto ret;
-	}
-
-	qdf_status = dp_rx_tm_enqueue_pkt(&dp_ext_hdl->rx_tm_hdl, nbuf_list);
-ret:
-	return qdf_status;
-}
-
-/**
- * dp_rx_gro_flush_ind() - Flush GRO packets for a given RX CTX Id
- * @soc: ol_txrx_soc_handle object
- * @rx_ctx_id: Context Id (Thread for which GRO packets need to be flushed)
- * @flush_code: flush_code differentiating normal_flush from low_tput_flush
- *
- * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
- */
-static inline
-QDF_STATUS dp_rx_gro_flush_ind(ol_txrx_soc_handle soc, int rx_ctx_id,
-			       enum dp_rx_gro_flush_code flush_code)
-{
-	struct dp_txrx_handle *dp_ext_hdl;
-	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
-
-	if (!soc) {
-		qdf_status = QDF_STATUS_E_INVAL;
-		dp_err("invalid input param soc %pK", soc);
-		goto ret;
-	}
-
-	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
-	if (!dp_ext_hdl) {
-		qdf_status = QDF_STATUS_E_FAULT;
-		goto ret;
-	}
-
-	qdf_status = dp_rx_tm_gro_flush_ind(&dp_ext_hdl->rx_tm_hdl, rx_ctx_id,
-					    flush_code);
-ret:
-	return qdf_status;
-}
-
-/**
- * dp_txrx_ext_dump_stats() - dump txrx external module stats
- * @soc: ol_txrx_soc_handle object
- * @stats_id: id  for the module whose stats are needed
- *
- * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
- */
-static inline QDF_STATUS dp_txrx_ext_dump_stats(ol_txrx_soc_handle soc,
-						uint8_t stats_id)
-{
-	struct dp_txrx_handle *dp_ext_hdl;
-	QDF_STATUS qdf_status;
-
-	if (!soc) {
-		dp_err("invalid input params soc %pK", soc);
-		return QDF_STATUS_E_INVAL;
-	}
-
-	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
-	if (!dp_ext_hdl) {
-		return QDF_STATUS_E_FAULT;
-	}
-
-	if (stats_id == CDP_DP_RX_THREAD_STATS)
-		qdf_status = dp_rx_tm_dump_stats(&dp_ext_hdl->rx_tm_hdl);
-	else
-		qdf_status = QDF_STATUS_E_INVAL;
-
-	return qdf_status;
-}
-
-/**
- * dp_rx_get_napi_context() - get NAPI context for a RX CTX ID
- * @soc: ol_txrx_soc_handle object
- * @rx_ctx_id: RX context ID (RX thread ID) corresponding to which NAPI is
- *             needed
- *
- * Return: NULL on failure, else pointer to NAPI corresponding to rx_ctx_id
- */
-static inline
-struct napi_struct *dp_rx_get_napi_context(ol_txrx_soc_handle soc,
-					   uint8_t rx_ctx_id)
-{
-	struct dp_txrx_handle *dp_ext_hdl;
-
-	if (!soc) {
-		dp_err("soc in NULL!");
-		return NULL;
-	}
-
-	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
-	if (!dp_ext_hdl) {
-		dp_err("dp_ext_hdl in NULL!");
-		return NULL;
-	}
-
-	return dp_rx_tm_get_napi_context(&dp_ext_hdl->rx_tm_hdl, rx_ctx_id);
-}
-
-/**
- * dp_txrx_set_cpu_mask() - set CPU mask for RX threads
- * @soc: ol_txrx_soc_handle object
- * @new_mask: New CPU mask pointer
- *
- * Return: QDF_STATUS_SUCCESS on success, error qdf status on failure
- */
-static inline
-QDF_STATUS dp_txrx_set_cpu_mask(ol_txrx_soc_handle soc, qdf_cpu_mask *new_mask)
-{
-	struct dp_txrx_handle *dp_ext_hdl;
-	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
-
-	if (!soc) {
-		qdf_status = QDF_STATUS_E_INVAL;
-		goto ret;
-	}
-
-	dp_ext_hdl = cdp_soc_get_dp_txrx_handle(soc);
-	if (!dp_ext_hdl) {
-		qdf_status = QDF_STATUS_E_FAULT;
-		goto ret;
-	}
-
-	qdf_status = dp_rx_tm_set_cpu_mask(&dp_ext_hdl->rx_tm_hdl, new_mask);
-
-ret:
-	return qdf_status;
-}
-
-#else
-
-static inline
-QDF_STATUS dp_txrx_init(ol_txrx_soc_handle soc, uint8_t pdev_id,
-			struct dp_txrx_config *config)
-{
-	return QDF_STATUS_SUCCESS;
-}
-
-static inline QDF_STATUS dp_txrx_deinit(ol_txrx_soc_handle soc)
-{
-	return QDF_STATUS_SUCCESS;
-}
-
-static inline QDF_STATUS dp_txrx_flush_pkts_by_vdev_id(ol_txrx_soc_handle soc,
-						       uint8_t vdev_id)
-{
-	return QDF_STATUS_SUCCESS;
-}
-
-static inline QDF_STATUS dp_txrx_resume(ol_txrx_soc_handle soc)
-{
-	return QDF_STATUS_SUCCESS;
-}
-
-static inline QDF_STATUS dp_txrx_suspend(ol_txrx_soc_handle soc)
-{
-	return QDF_STATUS_SUCCESS;
-}
-
-static inline
-QDF_STATUS dp_rx_enqueue_pkt(ol_txrx_soc_handle soc, qdf_nbuf_t nbuf_list)
-{
-	return QDF_STATUS_SUCCESS;
-}
-
-static inline
-QDF_STATUS dp_rx_gro_flush_ind(ol_txrx_soc_handle soc, int rx_ctx_id,
-			       enum dp_rx_gro_flush_code flush_code)
-{
-	return QDF_STATUS_SUCCESS;
-}
-
-static inline QDF_STATUS dp_txrx_ext_dump_stats(ol_txrx_soc_handle soc,
-						uint8_t stats_id)
-{
-	return QDF_STATUS_SUCCESS;
-}
-
-static inline
-struct napi_struct *dp_rx_get_napi_context(ol_txrx_soc_handle soc,
-					   uint8_t rx_ctx_id)
-{
-	return NULL;
-}
-
-static inline
-QDF_STATUS dp_txrx_set_cpu_mask(ol_txrx_soc_handle soc, qdf_cpu_mask *new_mask)
-{
-	return QDF_STATUS_SUCCESS;
-}
-
-#endif /* FEATURE_WLAN_DP_RX_THREADS */
-
-/**
- * dp_rx_tm_get_pending() - get number of frame in thread
- * nbuf queue pending
- * @soc: ol_txrx_soc_handle object
- *
- * Return: number of frames
- */
-int dp_rx_tm_get_pending(ol_txrx_soc_handle soc);
-
-#endif /* _DP_TXRX_H */