diff --git a/components/dp/core/inc/wlan_dp_priv.h b/components/dp/core/inc/wlan_dp_priv.h index f730f21bc1..c36dc32e8b 100644 --- a/components/dp/core/inc/wlan_dp_priv.h +++ b/components/dp/core/inc/wlan_dp_priv.h @@ -35,14 +35,6 @@ #include "pld_common.h" #include "wlan_dp_nud_tracking.h" -#ifndef NUM_CPUS -#ifdef QCA_CONFIG_SMP -#define NUM_CPUS NR_CPUS -#else -#define NUM_CPUS 1 -#endif -#endif - #ifndef NUM_TX_RX_HISTOGRAM #define NUM_TX_RX_HISTOGRAM 128 #endif @@ -121,11 +113,6 @@ struct wlan_dp_psoc_cfg { bool enable_latency_crit_clients; #endif /*WLAN_FEATURE_DP_BUS_BANDWIDTH*/ -#ifdef WLAN_FEATURE_MSCS - uint32_t mscs_pkt_threshold; - uint32_t mscs_voice_interval; -#endif /* WLAN_FEATURE_MSCS */ - #ifdef QCA_SUPPORT_TXRX_DRIVER_TCP_DEL_ACK bool del_ack_enable; uint32_t del_ack_threshold_high; @@ -133,7 +120,6 @@ struct wlan_dp_psoc_cfg { uint16_t del_ack_timer_value; uint16_t del_ack_pkt_count; #endif - uint32_t napi_cpu_affinity_mask; /* CPU affinity mask for rx_thread */ uint32_t rx_thread_ul_affinity_mask; uint32_t rx_thread_affinity_mask; @@ -157,8 +143,6 @@ struct wlan_dp_psoc_cfg { uint32_t fisa_enable; int icmp_req_to_fw_mark_interval; - - uint32_t cfg_wmi_credit_cnt; }; /** @@ -194,52 +178,6 @@ struct tx_rx_histogram { uint64_t qtime; }; -struct dp_tx_rx_stats { - struct { - /* start_xmit stats */ - __u32 tx_called; - __u32 tx_dropped; - __u32 tx_orphaned; - __u32 tx_classified_ac[WLAN_MAX_AC]; - __u32 tx_dropped_ac[WLAN_MAX_AC]; -#ifdef TX_MULTIQ_PER_AC - /* Neither valid socket nor skb->hash */ - uint32_t inv_sk_and_skb_hash; - /* skb->hash already calculated */ - uint32_t qselect_existing_skb_hash; - /* valid tx queue id in socket */ - uint32_t qselect_sk_tx_map; - /* skb->hash calculated in select queue */ - uint32_t qselect_skb_hash_calc; -#endif - /* rx stats */ - __u32 rx_packets; - __u32 rx_dropped; - __u32 rx_delivered; - __u32 rx_refused; - } per_cpu[NUM_CPUS]; - - qdf_atomic_t rx_usolict_arp_n_mcast_drp; - - /* rx gro */ - __u32 rx_aggregated; - __u32 rx_gro_dropped; - __u32 rx_non_aggregated; - __u32 rx_gro_flush_skip; - __u32 rx_gro_low_tput_flush; - - /* txflow stats */ - bool is_txflow_paused; - __u32 txflow_pause_cnt; - __u32 txflow_unpause_cnt; - __u32 txflow_timer_cnt; - - /*tx timeout stats*/ - __u32 tx_timeout_cnt; - __u32 cont_txtimeout_cnt; - u64 jiffies_last_txtimeout; -}; - /** * struct dp_stats - DP stats * @tx_rx_stats : Tx/Rx debug stats diff --git a/components/dp/core/src/wlan_dp_main.c b/components/dp/core/src/wlan_dp_main.c index 884c071c40..f0556e25f9 100644 --- a/components/dp/core/src/wlan_dp_main.c +++ b/components/dp/core/src/wlan_dp_main.c @@ -305,9 +305,275 @@ void dp_set_dump_dp_trace(uint16_t cmd_type, uint16_t count) { } #endif +#ifdef WLAN_FEATURE_DP_BUS_BANDWIDTH +/** + * dp_ini_bus_bandwidth() - Initialize INIs concerned about bus bandwidth + * @config: pointer to dp config + * @psoc: pointer to psoc obj + * + * Return: none + */ +static void dp_ini_bus_bandwidth(struct wlan_dp_psoc_cfg *config, + struct wlan_objmgr_psoc *psoc) +{ + config->bus_bw_ultra_high_threshold = + cfg_get(psoc, CFG_DP_BUS_BANDWIDTH_ULTRA_HIGH_THRESHOLD); + config->bus_bw_very_high_threshold = + cfg_get(psoc, CFG_DP_BUS_BANDWIDTH_VERY_HIGH_THRESHOLD); + config->bus_bw_dbs_threshold = + cfg_get(psoc, CFG_DP_BUS_BANDWIDTH_DBS_THRESHOLD); + config->bus_bw_high_threshold = + cfg_get(psoc, CFG_DP_BUS_BANDWIDTH_HIGH_THRESHOLD); + config->bus_bw_medium_threshold = + cfg_get(psoc, CFG_DP_BUS_BANDWIDTH_MEDIUM_THRESHOLD); + config->bus_bw_low_threshold = + cfg_get(psoc, CFG_DP_BUS_BANDWIDTH_LOW_THRESHOLD); + config->bus_bw_compute_interval = + cfg_get(psoc, CFG_DP_BUS_BANDWIDTH_COMPUTE_INTERVAL); + config->bus_low_cnt_threshold = + cfg_get(psoc, CFG_DP_BUS_LOW_BW_CNT_THRESHOLD); + config->enable_latency_crit_clients = + cfg_get(psoc, CFG_DP_BUS_HANDLE_LATENCY_CRITICAL_CLIENTS); +} +/** + * dp_ini_tcp_settings() - Initialize INIs concerned about tcp settings + * @config: pointer to dp config + * @psoc: pointer to psoc obj + * + * Return: none + */ +static void dp_ini_tcp_settings(struct wlan_dp_psoc_cfg *config, + struct wlan_objmgr_psoc *psoc) +{ + config->enable_tcp_limit_output = + cfg_get(psoc, CFG_DP_ENABLE_TCP_LIMIT_OUTPUT); + config->enable_tcp_adv_win_scale = + cfg_get(psoc, CFG_DP_ENABLE_TCP_ADV_WIN_SCALE); + config->enable_tcp_delack = + cfg_get(psoc, CFG_DP_ENABLE_TCP_DELACK); + config->tcp_delack_thres_high = + cfg_get(psoc, CFG_DP_TCP_DELACK_THRESHOLD_HIGH); + config->tcp_delack_thres_low = + cfg_get(psoc, CFG_DP_TCP_DELACK_THRESHOLD_LOW); + config->tcp_delack_timer_count = + cfg_get(psoc, CFG_DP_TCP_DELACK_TIMER_COUNT); + config->tcp_tx_high_tput_thres = + cfg_get(psoc, CFG_DP_TCP_TX_HIGH_TPUT_THRESHOLD); + config->enable_tcp_param_update = + cfg_get(psoc, CFG_DP_ENABLE_TCP_PARAM_UPDATE); +} + +#else +static void dp_ini_bus_bandwidth(struct wlan_dp_psoc_cfg *config, + struct wlan_objmgr_psoc *psoc) +{ +} + +static void dp_ini_tcp_settings(struct wlan_dp_psoc_cfg *config, + struct wlan_objmgr_psoc *psoc) +{ +} +#endif /*WLAN_FEATURE_DP_BUS_BANDWIDTH*/ + +#ifdef CONFIG_DP_TRACE +/** + * dp_trace_cfg_update() - initialize DP Trace config + * @config : Configuration paramerts + * @psoc: psoc handle + */ +static void +dp_trace_cfg_update(struct wlan_dp_psoc_cfg *config, + struct wlan_objmgr_psoc *psoc) +{ + qdf_size_t array_out_size; + + config->enable_dp_trace = cfg_get(psoc, CFG_DP_ENABLE_DP_TRACE); + qdf_uint8_array_parse(cfg_get(psoc, CFG_DP_DP_TRACE_CONFIG), + config->dp_trace_config, + sizeof(config->dp_trace_config), &array_out_size); + config->dp_proto_event_bitmap = cfg_get(psoc, + CFG_DP_PROTO_EVENT_BITMAP); +} +#else +static void +dp_trace_cfg_update(struct wlan_dp_psoc_cfg *config, + struct wlan_objmgr_psoc *psoc) +{ +} +#endif +#ifdef WLAN_NUD_TRACKING +/** + * dp_nud_tracking_cfg_update() - initialize NUD Tracking config + * @config : Configuration paramerts + * @psoc: psoc handle + */ +static void +dp_nud_tracking_cfg_update(struct wlan_dp_psoc_cfg *config, + struct wlan_objmgr_psoc *psoc) +{ + config->enable_nud_tracking = cfg_get(psoc, CFG_DP_ENABLE_NUD_TRACKING); +} +#else +static void +dp_nud_tracking_cfg_update(struct wlan_dp_psoc_cfg *config, + struct wlan_objmgr_psoc *psoc) +{ +} +#endif + +#ifdef QCA_SUPPORT_TXRX_DRIVER_TCP_DEL_ACK +/** + * dp_ini_tcp_del_ack_settings() - initialize TCP delack config + * @config : Configuration paramerts + * @psoc: psoc handle + */ +static void dp_ini_tcp_del_ack_settings(struct wlan_dp_psoc_cfg *config, + struct wlan_objmgr_psoc *psoc) +{ + config->del_ack_threshold_high = + cfg_get(psoc, CFG_DP_DRIVER_TCP_DELACK_HIGH_THRESHOLD); + config->del_ack_threshold_low = + cfg_get(psoc, CFG_DP_DRIVER_TCP_DELACK_LOW_THRESHOLD); + config->del_ack_enable = + cfg_get(psoc, CFG_DP_DRIVER_TCP_DELACK_ENABLE); + config->del_ack_pkt_count = + cfg_get(psoc, CFG_DP_DRIVER_TCP_DELACK_PKT_CNT); + config->del_ack_timer_value = + cfg_get(psoc, CFG_DP_DRIVER_TCP_DELACK_TIMER_VALUE); +} +#else +static void dp_ini_tcp_del_ack_settings(struct wlan_dp_psoc_cfg *config, + struct wlan_objmgr_psoc *psoc) +{ +} +#endif + +#ifdef WLAN_SUPPORT_TXRX_HL_BUNDLE +/** + * dp_hl_bundle_cfg_update() - initialize TxRx HL bundle config + * @config : Configuration paramerts + * @psoc: psoc handle + */ +static void dp_hl_bundle_cfg_update(struct wlan_dp_psoc_cfg *config, + struct wlan_objmgr_psoc *psoc) +{ + config->pkt_bundle_threshold_high = + cfg_get(psoc, CFG_DP_HL_BUNDLE_HIGH_TH); + config->pkt_bundle_threshold_low = + cfg_get(psoc, CFG_DP_HL_BUNDLE_LOW_TH); + config->pkt_bundle_timer_value = + cfg_get(psoc, CFG_DP_HL_BUNDLE_TIMER_VALUE); + config->pkt_bundle_size = + cfg_get(psoc, CFG_DP_HL_BUNDLE_SIZE); +} +#else +static void dp_hl_bundle_cfg_update(struct wlan_dp_psoc_cfg *config, + struct wlan_objmgr_psoc *psoc) +{ +} +#endif + +/** + * dp_set_rx_mode_value() - set rx_mode values + * @dp_ctx: DP context + * + * Return: none + */ +static void dp_set_rx_mode_value(struct wlan_dp_psoc_context *dp_ctx) +{ + uint32_t rx_mode = dp_ctx->dp_cfg.rx_mode; + enum QDF_GLOBAL_MODE con_mode = 0; + + con_mode = cds_get_conparam(); + + /* RPS has higher priority than dynamic RPS when both bits are set */ + if (rx_mode & CFG_ENABLE_RPS && rx_mode & CFG_ENABLE_DYNAMIC_RPS) + rx_mode &= ~CFG_ENABLE_DYNAMIC_RPS; + + if (rx_mode & CFG_ENABLE_RX_THREAD && rx_mode & CFG_ENABLE_RPS) { + dp_warn("rx_mode wrong configuration. Make it default"); + rx_mode = CFG_RX_MODE_DEFAULT; + } + + if (rx_mode & CFG_ENABLE_RX_THREAD) { + dp_ctx->enable_rxthread = true; + } else if (rx_mode & CFG_ENABLE_DP_RX_THREADS) { + if (con_mode == QDF_GLOBAL_MONITOR_MODE) + dp_ctx->enable_dp_rx_threads = false; + else + dp_ctx->enable_dp_rx_threads = true; + } + + if (rx_mode & CFG_ENABLE_RPS) + dp_ctx->rps = true; + + if (rx_mode & CFG_ENABLE_NAPI) + dp_ctx->napi_enable = true; + + if (rx_mode & CFG_ENABLE_DYNAMIC_RPS) + dp_ctx->dynamic_rps = true; + + dp_info("rx_mode:%u dp_rx_threads:%u rx_thread:%u napi:%u rps:%u dynamic rps %u", + rx_mode, dp_ctx->enable_dp_rx_threads, + dp_ctx->enable_rxthread, dp_ctx->napi_enable, + dp_ctx->rps, dp_ctx->dynamic_rps); +} + +/** + * dp_cfg_init() - initialize target specific configuration + * @ctx: dp context handle + */ static void dp_cfg_init(struct wlan_dp_psoc_context *ctx) { + struct wlan_dp_psoc_cfg *config = &ctx->dp_cfg; + struct wlan_objmgr_psoc *psoc = ctx->psoc; + uint16_t cfg_len; + + cfg_len = qdf_str_len(cfg_get(psoc, CFG_DP_RPS_RX_QUEUE_CPU_MAP_LIST)) + + 1; + dp_ini_bus_bandwidth(config, psoc); + dp_ini_tcp_settings(config, psoc); + + dp_ini_tcp_del_ack_settings(config, psoc); + + dp_hl_bundle_cfg_update(config, psoc); + + config->rx_thread_ul_affinity_mask = + cfg_get(psoc, CFG_DP_RX_THREAD_UL_CPU_MASK); + config->rx_thread_affinity_mask = + cfg_get(psoc, CFG_DP_RX_THREAD_CPU_MASK); + config->fisa_enable = cfg_get(psoc, CFG_DP_RX_FISA_ENABLE); + if (cfg_len < CFG_DP_RPS_RX_QUEUE_CPU_MAP_LIST_LEN) { + qdf_str_lcopy(config->cpu_map_list, + cfg_get(psoc, CFG_DP_RPS_RX_QUEUE_CPU_MAP_LIST), + cfg_len); + } else { + dp_err("ini string length greater than max size %d", + CFG_DP_RPS_RX_QUEUE_CPU_MAP_LIST_LEN); + cfg_len = qdf_str_len(cfg_default(CFG_DP_RPS_RX_QUEUE_CPU_MAP_LIST)); + qdf_str_lcopy(config->cpu_map_list, + cfg_default(CFG_DP_RPS_RX_QUEUE_CPU_MAP_LIST), + cfg_len); + } + config->tx_orphan_enable = cfg_get(psoc, CFG_DP_TX_ORPHAN_ENABLE); + config->rx_mode = cfg_get(psoc, CFG_DP_RX_MODE); + dp_set_rx_mode_value(ctx); + config->multicast_replay_filter = + cfg_get(psoc, CFG_DP_FILTER_MULTICAST_REPLAY); + config->rx_wakelock_timeout = + cfg_get(psoc, CFG_DP_RX_WAKELOCK_TIMEOUT); + config->num_dp_rx_threads = cfg_get(psoc, CFG_DP_NUM_DP_RX_THREADS); + config->icmp_req_to_fw_mark_interval = + cfg_get(psoc, CFG_DP_ICMP_REQ_TO_FW_MARK_INTERVAL); + + config->rx_softirq_max_yield_duration_ns = + cfg_get(psoc, + CFG_DP_RX_SOFTIRQ_MAX_YIELD_TIME_NS); + + dp_trace_cfg_update(config, psoc); + dp_nud_tracking_cfg_update(config, psoc); + dp_trace_cfg_update(config, psoc); } /** diff --git a/components/dp/core/src/wlan_dp_periodic_sta_stats.c b/components/dp/core/src/wlan_dp_periodic_sta_stats.c index ae83ee2fef..08c66f09c2 100644 --- a/components/dp/core/src/wlan_dp_periodic_sta_stats.c +++ b/components/dp/core/src/wlan_dp_periodic_sta_stats.c @@ -76,6 +76,10 @@ void dp_periodic_sta_stats_display(struct wlan_dp_psoc_context *dp_ctx) void dp_periodic_sta_stats_config(struct dp_config *config, struct wlan_objmgr_psoc *psoc) { + config->periodic_stats_timer_interval = + cfg_get(psoc, CFG_PERIODIC_STATS_TIMER_INTERVAL); + config->periodic_stats_timer_duration = + cfg_get(psoc, CFG_PERIODIC_STATS_TIMER_DURATION); } void dp_periodic_sta_stats_start(struct wlan_objmgr_vdev *vdev) diff --git a/components/dp/dispatcher/inc/wlan_dp_cfg.h b/components/dp/dispatcher/inc/wlan_dp_cfg.h index 9922729ad1..ad3d812cfd 100644 --- a/components/dp/dispatcher/inc/wlan_dp_cfg.h +++ b/components/dp/dispatcher/inc/wlan_dp_cfg.h @@ -64,5 +64,1161 @@ /* Default verbosity, in case its missing in gDptraceConfig string*/ #define DP_TRACE_CONFIG_DEFAULT_VERBOSTY QDF_DP_TRACE_VERBOSITY_LOW + #endif + +#define CFG_ENABLE_RX_THREAD BIT(0) +#define CFG_ENABLE_RPS BIT(1) +#define CFG_ENABLE_NAPI BIT(2) +#define CFG_ENABLE_DYNAMIC_RPS BIT(3) +#define CFG_ENABLE_DP_RX_THREADS BIT(4) +#define CFG_RX_MODE_MAX (CFG_ENABLE_RX_THREAD | \ + CFG_ENABLE_RPS | \ + CFG_ENABLE_NAPI | \ + CFG_ENABLE_DYNAMIC_RPS | \ + CFG_ENABLE_DP_RX_THREADS) +#ifdef MDM_PLATFORM +#define CFG_RX_MODE_DEFAULT 0 +#elif defined(HELIUMPLUS) +#define CFG_RX_MODE_DEFAULT CFG_ENABLE_NAPI +#endif + +#ifndef CFG_RX_MODE_DEFAULT +#if defined(FEATURE_WLAN_DP_RX_THREADS) +#define CFG_RX_MODE_DEFAULT (CFG_ENABLE_DP_RX_THREADS | CFG_ENABLE_NAPI) +#else +#define CFG_RX_MODE_DEFAULT (CFG_ENABLE_RX_THREAD | CFG_ENABLE_NAPI) +#endif +#endif + +/* Max # of packets to be processed in 1 tx comp loop */ +#define CFG_DP_TX_COMP_LOOP_PKT_LIMIT_DEFAULT 64 +#define CFG_DP_TX_COMP_LOOP_PKT_LIMIT_MAX (1024 * 1024) + +/*Max # of packets to be processed in 1 rx reap loop */ +#define CFG_DP_RX_REAP_LOOP_PKT_LIMIT_DEFAULT 64 +#define CFG_DP_RX_REAP_LOOP_PKT_LIMIT_MAX (1024 * 1024) + +/* Max # of HP OOS (out of sync) updates */ +#define CFG_DP_RX_HP_OOS_UPDATE_LIMIT_DEFAULT 0 +#define CFG_DP_RX_HP_OOS_UPDATE_LIMIT_MAX 1024 + +/* Max Yield time duration for RX Softirq */ +#define CFG_DP_RX_SOFTIRQ_MAX_YIELD_TIME_NS_DEFAULT (500 * 1000) +#define CFG_DP_RX_SOFTIRQ_MAX_YIELD_TIME_NS_MAX (10 * 1000 * 1000) + +#ifdef WLAN_FEATURE_DP_BUS_BANDWIDTH +/* + * + * gBusBandwidthUltraHighThreshold - bus bandwidth ultra high threshold + * + * @Min: 0 + * @Max: 4294967295UL + * @Default: 12000 + * + * This ini specifies the bus bandwidth very high threshold + * + * Usage: Internal + * + * + */ +#define CFG_DP_BUS_BANDWIDTH_ULTRA_HIGH_THRESHOLD \ + CFG_INI_UINT( \ + "gBusBandwidthUltraHighThreshold", \ + 0, \ + 4294967295UL, \ + 12000, \ + CFG_VALUE_OR_DEFAULT, \ + "Bus bandwidth ultra high threshold") + +/* + * + * gBusBandwidthVeryHighThreshold - bus bandwidth very high threshold + * + * @Min: 0 + * @Max: 4294967295UL + * @Default: 10000 + * + * This ini specifies the bus bandwidth very high threshold + * + * Usage: Internal + * + * + */ +#define CFG_DP_BUS_BANDWIDTH_VERY_HIGH_THRESHOLD \ + CFG_INI_UINT( \ + "gBusBandwidthVeryHighThreshold", \ + 0, \ + 4294967295UL, \ + 10000, \ + CFG_VALUE_OR_DEFAULT, \ + "Bus bandwidth very high threshold") +/* + * + * gBusBandwidthDBSThreshold - bus bandwidth for DBS mode threshold + * + * @Min: 0 + * @Max: 4294967295UL + * @Default: 6000 + * + * This ini specifies the bus bandwidth high threshold + * + * Usage: Internal + * + * + */ +#define CFG_DP_BUS_BANDWIDTH_DBS_THRESHOLD \ + CFG_INI_UINT( \ + "gBusBandwidthDBSThreshold", \ + 0, \ + 4294967295UL, \ + 6000, \ + CFG_VALUE_OR_DEFAULT, \ + "Bus bandwidth DBS mode threshold") +/* + * + * gBusBandwidthHighThreshold - bus bandwidth high threshold + * + * @Min: 0 + * @Max: 4294967295UL + * @Default: 2000 + * + * This ini specifies the bus bandwidth high threshold + * + * Usage: Internal + * + * + */ +#define CFG_DP_BUS_BANDWIDTH_HIGH_THRESHOLD \ + CFG_INI_UINT( \ + "gBusBandwidthHighThreshold", \ + 0, \ + 4294967295UL, \ + 2000, \ + CFG_VALUE_OR_DEFAULT, \ + "Bus bandwidth high threshold") + +/* + * + * gBusBandwidthMediumThreshold - bus bandwidth medium threshold + * + * @Min: 0 + * @Max: 4294967295UL + * @Default: 500 + * + * This ini specifies the bus bandwidth medium threshold + * + * Usage: Internal + * + * + */ +#define CFG_DP_BUS_BANDWIDTH_MEDIUM_THRESHOLD \ + CFG_INI_UINT( \ + "gBusBandwidthMediumThreshold", \ + 0, \ + 4294967295UL, \ + 500, \ + CFG_VALUE_OR_DEFAULT, \ + "Bus bandwidth medium threshold") + +/* + * + * gBusBandwidthLowThreshold - bus bandwidth low threshold + * + * @Min: 0 + * @Max: 4294967295UL + * @Default: 150 + * + * This ini specifies the bus bandwidth low threshold + * + * Usage: Internal + * + * + */ +#define CFG_DP_BUS_BANDWIDTH_LOW_THRESHOLD \ + CFG_INI_UINT( \ + "gBusBandwidthLowThreshold", \ + 0, \ + 4294967295UL, \ + 150, \ + CFG_VALUE_OR_DEFAULT, \ + "Bus bandwidth low threshold") + +/* + * + * gBusBandwidthComputeInterval - bus bandwidth compute interval + * + * @Min: 0 + * @Max: 10000 + * @Default: 100 + * + * This ini specifies thebus bandwidth compute interval + * + * Usage: Internal + * + * + */ +#define CFG_DP_BUS_BANDWIDTH_COMPUTE_INTERVAL \ + CFG_INI_UINT( \ + "gBusBandwidthComputeInterval", \ + 0, \ + 10000, \ + 100, \ + CFG_VALUE_OR_DEFAULT, \ + "Bus bandwidth compute interval") + +/* + * + * gTcpLimitOutputEnable - Control to enable TCP limit output byte + * @Default: true + * + * This ini is used to enable dynamic configuration of TCP limit output bytes + * tcp_limit_output_bytes param. Enabling this will let driver post message to + * cnss-daemon, accordingly cnss-daemon will modify the tcp_limit_output_bytes. + * + * Supported Feature: Tcp limit output bytes + * + * Usage: Internal + * + * + */ +#define CFG_DP_ENABLE_TCP_LIMIT_OUTPUT \ + CFG_INI_BOOL( \ + "gTcpLimitOutputEnable", \ + true, \ + "Control to enable TCP limit output byte") + +/* + * + * gTcpAdvWinScaleEnable - Control to enable TCP adv window scaling + * @Default: true + * + * This ini is used to enable dynamic configuration of TCP adv window scaling + * system parameter. + * + * Supported Feature: Tcp Advance Window Scaling + * + * Usage: Internal + * + * + */ +#define CFG_DP_ENABLE_TCP_ADV_WIN_SCALE \ + CFG_INI_BOOL( \ + "gTcpAdvWinScaleEnable", \ + true, \ + "Control to enable TCP adv window scaling") + +/* + * + * gTcpDelAckEnable - Control to enable Dynamic Configuration of Tcp Delayed Ack + * @Default: true + * + * This ini is used to enable Dynamic Configuration of Tcp Delayed Ack + * + * Related: gTcpDelAckThresholdHigh, gTcpDelAckThresholdLow, + * gTcpDelAckTimerCount + * + * Supported Feature: Tcp Delayed Ack + * + * Usage: Internal + * + * + */ +#define CFG_DP_ENABLE_TCP_DELACK \ + CFG_INI_BOOL( \ + "gTcpDelAckEnable", \ + true, \ + "Control to enable Dynamic Config of Tcp Delayed Ack") + +/* + * + * gTcpDelAckThresholdHigh - High Threshold inorder to trigger TCP Del Ack + * indication + * @Min: 0 + * @Max: 16000 + * @Default: 500 + * + * This ini is used to mention the High Threshold inorder to trigger TCP Del Ack + * indication i.e the threshold of packets received over a period of 100 ms. + * i.e to have a low RX throughput requirement + * Related: gTcpDelAckEnable, gTcpDelAckThresholdLow, gTcpDelAckTimerCount + * + * Supported Feature: Tcp Delayed Ack + * + * Usage: Internal + * + * + */ +#define CFG_DP_TCP_DELACK_THRESHOLD_HIGH \ + CFG_INI_UINT( \ + "gTcpDelAckThresholdHigh", \ + 0, \ + 16000, \ + 500, \ + CFG_VALUE_OR_DEFAULT, \ + "High Threshold inorder to trigger TCP Del Ack") + +/* + * + * gTcpDelAckThresholdLow - Low Threshold inorder to trigger TCP Del Ack + * indication + * @Min: 0 + * @Max: 10000 + * @Default: 1000 + * + * This ini is used to mention the Low Threshold inorder to trigger TCP Del Ack + * indication i.e the threshold of packets received over a period of 100 ms. + * i.e to have a low RX throughput requirement + * + * Related: gTcpDelAckEnable, gTcpDelAckThresholdHigh, gTcpDelAckTimerCount + * + * Supported Feature: Tcp Delayed Ack + * + * Usage: Internal + * + * + */ +#define CFG_DP_TCP_DELACK_THRESHOLD_LOW \ + CFG_INI_UINT( \ + "gTcpDelAckThresholdLow", \ + 0, \ + 10000, \ + 1000, \ + CFG_VALUE_OR_DEFAULT, \ + "Low Threshold inorder to trigger TCP Del Ack") + +/* + * + * gTcpDelAckTimerCount - Del Ack Timer Count inorder to trigger TCP Del Ack + * indication + * @Min: 1 + * @Max: 1000 + * @Default: 30 + * + * This ini is used to mention the Del Ack Timer Count inorder to + * trigger TCP Del Ack indication i.e number of 100 ms periods + * + * Related: gTcpDelAckEnable, gTcpDelAckThresholdHigh, gTcpDelAckThresholdLow + * + * Supported Feature: Tcp Delayed Ack + * + * Usage: Internal + * + * + */ +#define CFG_DP_TCP_DELACK_TIMER_COUNT \ + CFG_INI_UINT( \ + "gTcpDelAckTimerCount", \ + 1, \ + 1000, \ + 30, \ + CFG_VALUE_OR_DEFAULT, \ + "Del Ack Timer Count inorder to trigger TCP Del Ack") + +/* + * + * gTcpTxHighTputThreshold - High Threshold inorder to trigger High + * Tx Throughput requirement. + * @Min: 0 + * @Max: 16000 + * @Default: 500 + * + * This ini specifies the threshold of packets transmitted + * over a period of 100 ms beyond which TCP can be considered to have a high + * TX throughput requirement. The driver uses this condition to tweak TCP TX + * specific parameters (via cnss-daemon) + * + * Supported Feature: To tweak TCP TX n/w parameters + * + * Usage: Internal + * + * + */ +#define CFG_DP_TCP_TX_HIGH_TPUT_THRESHOLD \ + CFG_INI_UINT( \ + "gTcpTxHighTputThreshold", \ + 0, \ + 16000, \ + 500, \ + CFG_VALUE_OR_DEFAULT, \ + "High Threshold inorder to trigger High Tx Tp") + +/* + * + * gBusLowTputCntThreshold - Threshold count to trigger low Tput + * GRO flush skip + * @Min: 0 + * @Max: 200 + * @Default: 10 + * + * This ini is a threshold that if count of times for bus Tput level + * PLD_BUS_WIDTH_LOW in bus_bw_timer() >= this threshold, will enable skipping + * GRO flush, current default threshold is 10, then will delay GRO flush-skip + * 1 second for low Tput level. + * + * Supported Feature: GRO flush skip when low T-put + * + * Usage: Internal + * + * + */ +#define CFG_DP_BUS_LOW_BW_CNT_THRESHOLD \ + CFG_INI_UINT( \ + "gBusLowTputCntThreshold", \ + 0, \ + 200, \ + 10, \ + CFG_VALUE_OR_DEFAULT, \ + "Threshold to trigger GRO flush skip for low T-put") + +/* + * + * gHandleLatencyCriticalClients - Enable the handling of latency critical + * clients in bus bandwidth timer. + * @Default: false + * + * This ini enables the handling of latency critical clients, eg: 11g/a + * clients, when they are running their corresponding peak throughput. + * + * Supported Feature: Latency critical clients in host + * + * Usage: External + * + * + */ +#define CFG_DP_BUS_HANDLE_LATENCY_CRITICAL_CLIENTS \ + CFG_INI_BOOL( \ + "gHandleLatencyCriticalClients", \ + false, \ + "Control to enable latency critical clients") + +#endif /*WLAN_FEATURE_DP_BUS_BANDWIDTH*/ + +#ifdef QCA_SUPPORT_TXRX_DRIVER_TCP_DEL_ACK +/* + * + * gDriverDelAckHighThreshold - High Threshold inorder to trigger TCP + * delay ack feature in the host. + * @Min: 0 + * @Max: 70000 + * @Default: 300 + * + * This ini specifies the threshold of RX packets transmitted + * over a period of 100 ms beyond which TCP delay ack can be enabled + * to improve TCP RX throughput requirement. + * + * Supported Feature: Tcp Delayed Ack in the host + * + * Usage: Internal + * + * + */ +#define CFG_DP_DRIVER_TCP_DELACK_HIGH_THRESHOLD \ + CFG_INI_UINT( \ + "gDriverDelAckHighThreshold", \ + 0, \ + 70000, \ + 300, \ + CFG_VALUE_OR_DEFAULT, \ + "TCP delack high threshold") + +/* + * + * gDriverDelAckLowThreshold - Low Threshold inorder to disable TCP + * delay ack feature in the host. + * @Min: 0 + * @Max: 70000 + * @Default: 100 + * + * This ini is used to mention the Low Threshold inorder to disable TCP Del + * Ack feature in the host. + * + * Supported Feature: Tcp Delayed Ack in the host + * + * Usage: Internal + * + * + */ +#define CFG_DP_DRIVER_TCP_DELACK_LOW_THRESHOLD \ + CFG_INI_UINT( \ + "gDriverDelAckLowThreshold", \ + 0, \ + 70000, \ + 100, \ + CFG_VALUE_OR_DEFAULT, \ + "TCP delack low threshold") + +/* + * + * gDriverDelAckTimerValue - Timeout value (ms) to send out all TCP del + * ack frames + * @Min: 1 + * @Max: 15 + * @Default: 3 + * + * This ini specifies the time out value to send out all pending TCP delay + * ACK frames. + * + * Supported Feature: Tcp Delayed Ack in the host + * + * Usage: Internal + * + * + */ +#define CFG_DP_DRIVER_TCP_DELACK_TIMER_VALUE \ + CFG_INI_UINT( \ + "gDriverDelAckTimerValue", \ + 1, \ + 15, \ + 3, \ + CFG_VALUE_OR_DEFAULT, \ + "Send out all TCP Del Acks if time out") + +/* + * + * gDriverDelAckPktCount - The maximum number of TCP delay ack frames + * @Min: 0 + * @Max: 50 + * @Default: 20 + * + * This ini specifies the maximum number of TCP delayed ack frames. + * + * Supported Feature: Tcp Delayed Ack in the host + * + * Usage: Internal + * + * + */ +#define CFG_DP_DRIVER_TCP_DELACK_PKT_CNT \ + CFG_INI_UINT( \ + "gDriverDelAckPktCount", \ + 0, \ + 50, \ + 20, \ + CFG_VALUE_OR_DEFAULT, \ + "No of TCP Del ACK count") + +/* + * + * gDriverDelAckEnable - Control to enable Dynamic Configuration of Tcp + * Delayed Ack in the host. + * @Default: true + * + * This ini is used to enable Dynamic Configuration of Tcp Delayed Ack + * in the host. + * + * Related: gDriverDelAckHighThreshold, gDriverDelAckLowThreshold, + * gDriverDelAckPktCount, gDriverDelAckTimerValue + * + * Supported Feature: Tcp Delayed Ack in the host + * + * Usage: Internal + * + * + */ +#define CFG_DP_DRIVER_TCP_DELACK_ENABLE \ + CFG_INI_BOOL( \ + "gDriverDelAckEnable", \ + true, \ + "Enable tcp del ack in the driver") +#endif + +/* + * + * RX_THREAD_CPU_AFFINITY_MASK - CPU mask to affine Rx_thread + * + * @Min: 0 + * @Max: 0xFF + * @Default: 0x02 + * + * This ini is used to set Rx_thread CPU affinity + * + * Supported Feature: Rx_thread + * + * Usage: Internal + * + * + */ +#ifdef RX_PERFORMANCE +#define CFG_DP_RX_THREAD_CPU_MASK \ + CFG_INI_UINT( \ + "RX_THREAD_CPU_AFFINITY_MASK", \ + 0, \ + 0xFF, \ + 0xFE, \ + CFG_VALUE_OR_DEFAULT, \ + "CPU mask to affine Rx_thread") +#else +#define CFG_DP_RX_THREAD_CPU_MASK \ + CFG_INI_UINT( \ + "RX_THREAD_CPU_AFFINITY_MASK", \ + 0, \ + 0xFF, \ + 0, \ + CFG_VALUE_OR_DEFAULT, \ + "CPU mask to affine Rx_thread") +#endif + +/* + * + * RX_THREAD_UL_CPU_AFFINITY_MASK - CPU mask to affine Rx_thread + * + * @Min: 0 + * @Max: 0xFF + * @Default: 0x0 + * + * This ini is used to set Rx_thread CPU affinity for uplink traffic + * + * Supported Feature: Rx_thread + * + * Usage: Internal + * + * + */ +#define CFG_DP_RX_THREAD_UL_CPU_MASK \ + CFG_INI_UINT( \ + "RX_THREAD_UL_CPU_AFFINITY_MASK", \ + 0, \ + 0xFF, \ + 0x0, \ + CFG_VALUE_OR_DEFAULT, \ + "CPU mask to affine Rx_thread for uplink traffic") + +/* + * + * rpsRxQueueCpuMapList - RPS map for different RX queues + * + * @Default: e + * + * This ini is used to set RPS map for different RX queues. + * + * List of RPS CPU maps for different rx queues registered by WLAN driver + * Ref - Kernel/Documentation/networking/scaling.txt + * RPS CPU map for a particular RX queue, selects CPU(s) for bottom half + * processing of RX packets. For example, for a system with 4 CPUs, + * 0xe: Use CPU1 - CPU3 and donot use CPU0. + * 0x0: RPS is disabled, packets are processed on the interrupting CPU. +.* + * WLAN driver registers NUM_TX_QUEUES queues for tx and rx each during + * alloc_netdev_mq. Hence, we need to have a cpu mask for each of the rx queues. + * + * For example, if the NUM_TX_QUEUES is 4, a sample WLAN ini entry may look like + * rpsRxQueueCpuMapList=a b c d + * For a 4 CPU system (CPU0 - CPU3), this implies: + * 0xa - (1010) use CPU1, CPU3 for rx queue 0 + * 0xb - (1011) use CPU0, CPU1 and CPU3 for rx queue 1 + * 0xc - (1100) use CPU2, CPU3 for rx queue 2 + * 0xd - (1101) use CPU0, CPU2 and CPU3 for rx queue 3 + + * In practice, we may want to avoid the cores which are heavily loaded. + * + * Default value of rpsRxQueueCpuMapList. Different platforms may have + * different configurations for NUM_TX_QUEUES and # of cpus, and will need to + * configure an appropriate value via ini file. Setting default value to 'e' to + * avoid use of CPU0 (since its heavily used by other system processes) by rx + * queue 0, which is currently being used for rx packet processing. + * + * Maximum length of string used to hold a list of cpu maps for various rx + * queues. Considering a 16 core system with 5 rx queues, a RPS CPU map + * list may look like - + * rpsRxQueueCpuMapList = ffff ffff ffff ffff ffff + * (all 5 rx queues can be processed on all 16 cores) + * max string len = 24 + 1(for '\0'). Considering 30 to be on safe side. + * + * Supported Feature: Rx_thread + * + * Usage: Internal + * + */ +#define CFG_DP_RPS_RX_QUEUE_CPU_MAP_LIST \ + CFG_INI_STRING( \ + "rpsRxQueueCpuMapList", \ + 1, \ + 30, \ + "e", \ + "specify RPS map for different RX queues") + +/* + * + * gEnableTxOrphan- Enable/Disable orphaning of Tx packets + * @Default: false + * + * This ini is used to enable/disable orphaning of Tx packets. + * + * Related: None + * + * Usage: External + * + * + */ +#define CFG_DP_TX_ORPHAN_ENABLE \ + CFG_INI_BOOL( \ + "gEnableTxOrphan", \ + false, \ + "orphaning of Tx packets") + +/* + * + * rx_mode - Control to decide rx mode for packet processing + * + * @Min: 0 + * @Max: (CFG_ENABLE_RX_THREAD | CFG_ENABLE_RPS | CFG_ENABLE_NAPI | \ + * CFG_ENABLE_DYNAMIC_RPS) + * + * Some possible configurations: + * rx_mode=0 - Uses tasklets for bottom half + * CFG_ENABLE_NAPI (rx_mode=4) - Uses NAPI for bottom half + * CFG_ENABLE_RX_THREAD | CFG_ENABLE_NAPI (rx_mode=5) - NAPI for bottom half, + * rx_thread for stack. Single threaded. + * CFG_ENABLE_DP_RX_THREAD | CFG_ENABLE_NAPI (rx_mode=10) - NAPI for bottom + * half, dp_rx_thread for stack processing. Supports multiple rx threads. + * + * Usage: Internal + * + * + */ +#define CFG_DP_RX_MODE \ + CFG_INI_UINT("rx_mode", \ + 0, CFG_RX_MODE_MAX, CFG_RX_MODE_DEFAULT, \ + CFG_VALUE_OR_DEFAULT, \ + "Control to decide rx mode for packet processing") + +/* + * + * tx_comp_loop_pkt_limit - Control to decide max # of packets to be processed + * in 1 tx comp loop + * + * @Min: 8 + * @Max: CFG_DP_TX_COMP_LOOP_PKT_LIMIT_MAX + * + * Usage: Internal + * + * + */ +#define CFG_DP_TX_COMP_LOOP_PKT_LIMIT \ + CFG_INI_UINT("tx_comp_loop_pkt_limit", \ + 1, CFG_DP_TX_COMP_LOOP_PKT_LIMIT_MAX, \ + CFG_DP_TX_COMP_LOOP_PKT_LIMIT_DEFAULT, \ + CFG_VALUE_OR_DEFAULT, \ + "Control to decide tx comp loop pkt limit") +/* + * + * rx_reap_loop_pkt_limit - Control to decide max # of packets to be reaped + * in 1 dp_rx_process reap loop + * + * @Min: 8 + * @Max: CFG_DP_RX_REAP_LOOP_PKT_LIMIT_MAX + * + * Usage: Internal + * + * + */ +#define CFG_DP_RX_REAP_LOOP_PKT_LIMIT \ + CFG_INI_UINT("rx_reap_loop_pkt_limit", \ + 0, CFG_DP_RX_REAP_LOOP_PKT_LIMIT_MAX, \ + CFG_DP_RX_REAP_LOOP_PKT_LIMIT_DEFAULT, \ + CFG_VALUE_OR_DEFAULT, \ + "Control to decide rx reap loop packet limit") + +/* + * + * rx_hp_oos_update_limit - Control to decide max # of HP OOS (out of sync) + * updates + * + * @Min: 0 + * @Max: CFG_DP_RX_HP_OOS_UPDATE_LIMIT_MAX + * + * Usage: Internal + * + * + */ +#define CFG_DP_RX_HP_OOS_UPDATE_LIMIT \ + CFG_INI_UINT("rx_hp_oos_update_limit", \ + 0, CFG_DP_RX_HP_OOS_UPDATE_LIMIT_MAX, \ + CFG_DP_RX_HP_OOS_UPDATE_LIMIT_DEFAULT, \ + CFG_VALUE_OR_DEFAULT, \ + "Control to decide HP OOS update limit") + +/* + * + * rx_softirq_max_yield_duration_ns - Control to decide max duration for RX + * softirq + * + * @Min: 100 * 1000 , 100us + * @Max: CFG_DP_RX_SOFTIRQ_MAX_YIELD_TIME_NS_MAX + * + * Usage: Internal + * + * + */ +#define CFG_DP_RX_SOFTIRQ_MAX_YIELD_TIME_NS \ + CFG_INI_UINT("rx_softirq_max_yield_duration_ns", \ + 100 * 1000, CFG_DP_RX_SOFTIRQ_MAX_YIELD_TIME_NS_MAX, \ + CFG_DP_RX_SOFTIRQ_MAX_YIELD_TIME_NS_DEFAULT, \ + CFG_VALUE_OR_DEFAULT, \ + "max yield time duration for RX Softirq") + +/* + * + * enable_multicast_replay_filter - Enable filtering of replayed multicast + * packets + * + * In a typical infrastructure setup, it is quite normal to receive + * replayed multicast packets. These packets may cause more harm than + * help if not handled properly. Providing a configuration option + * to enable filtering of such packets + * + * + */ +#define CFG_DP_FILTER_MULTICAST_REPLAY \ + CFG_INI_BOOL("enable_multicast_replay_filter", \ + true, "Enable filtering of replayed multicast packets") + +/* + * + * rx_wakelock_timeout - Amount of time to hold wakelock for RX unicast packets + * @Min: 0 + * @Max: 100 + * @Default: 50 + * + * This ini item configures the amount of time, in milliseconds, that the driver + * should prevent system power collapse after receiving an RX unicast packet. + * A conigured value of 0 disables the RX Wakelock feature completely. + * + * Related: None. + * + * Supported Feature: RX Wakelock + * + * Usage: Internal/External + * + * + */ +#define CFG_DP_RX_WAKELOCK_TIMEOUT \ + CFG_INI_UINT("rx_wakelock_timeout", \ + 0, 100, 50, CFG_VALUE_OR_DEFAULT, \ + "Amount of time to hold wakelock for RX unicast packets") + +/* + * + * num_dp_rx_threads - Control to set the number of dp rx threads + * + * @Min: 1 + * @Max: 4 + * @Default: 1 + * + * Usage: Internal + * + * + */ +#define CFG_DP_NUM_DP_RX_THREADS \ + CFG_INI_UINT("num_dp_rx_threads", \ + 1, 4, 1, CFG_VALUE_OR_DEFAULT, \ + "Control to set the number of dp rx threads") + +/* + * + * ce_service_max_rx_ind_flush - Maximum number of HTT messages + * to be processed per NAPI poll + * + * @Min: 1 + * @Max: 32 + * @Default: 1 + * + * Usage: Internal + * + * + */ +#define CFG_DP_CE_SERVICE_MAX_RX_IND_FLUSH \ + CFG_INI_UINT("ce_service_max_rx_ind_flush", \ + 1, 32, 1, \ + CFG_VALUE_OR_DEFAULT, "Ctrl to set ce service max rx ind flsh") + +/* + * + * ce_service_max_yield_time - Time in microseconds after which + * a NAPI poll must yield + * + * @Min: 500 + * @Max: 10000 + * @Default: 500 + * + * Usage: Internal + * + * + */ +#define CFG_DP_CE_SERVICE_MAX_YIELD_TIME \ + CFG_INI_UINT("ce_service_max_yield_time", \ + 500, 10000, 500, \ + CFG_VALUE_OR_DEFAULT, "Ctrl to set ce service max yield time") + +#ifdef WLAN_FEATURE_FASTPATH +#define CFG_DP_ENABLE_FASTPATH \ + CFG_INI_BOOL("gEnableFastPath", \ + false, "Ctrl to enable fastpath feature") + +#define CFG_DP_ENABLE_FASTPATH_ALL \ + CFG(CFG_DP_ENABLE_FASTPATH) +#else +#define CFG_DP_ENABLE_FASTPATH_ALL +#endif + +#define CFG_DP_ENABLE_TCP_PARAM_UPDATE \ + CFG_INI_BOOL("enable_tcp_param_update", \ + false, "configure TCP param through Wi-Fi HAL") +/* + * + * + * Enable/disable DPTRACE + * Enabling this might have performace impact. + * + * Config DPTRACE + * The sequence of params is important. If some param is missing, defaults are + * considered. + * Param 1: Enable/Disable DP Trace live mode (uint8_t) + * Param 2: DP Trace live mode high bandwidth thresh.(uint8_t) + * (packets/second) beyond which DP Trace is disabled. Decimal Val. + * MGMT, DHCP, EAPOL, ARP pkts are not counted. ICMP and Data are. + * Param 3: Default Verbosity (0-4) + * Param 4: Proto Bitmap (uint8_t). Decimal Value. + * (decimal 62 = 0x3e) + * e.g., to disable live mode, use the following param in the ini file. + * gDptraceConfig = 0 + * e.g., to enable dptrace live mode and set the thresh as 6, + * use the following param in the ini file. + * gDptraceConfig = 1, 6 + * + * + */ +#ifdef CONFIG_DP_TRACE +#define CFG_DP_ENABLE_DP_TRACE \ + CFG_INI_BOOL("enable_dp_trace", \ + true, "Ctrl to enable dp trace feature") + +#define CFG_DP_DP_TRACE_CONFIG \ + CFG_INI_STRING( \ + "gDptraceConfig", \ + 1, \ + 20, \ + "1, 6, 2, 126", \ + "dp trace configuration string") + +/* + * + * dp_proto_event_bitmap - Control for which protocol packet diag event should + * be sent to user space. + * @Min: 0 + * @Max: 0x17 + * @Default: 0x6 + * + * This ini is used to control for which protocol packet diag event should be + * sent to user space. + * + * QDF_NBUF_PKT_TRAC_TYPE_DNS 0x01 + * QDF_NBUF_PKT_TRAC_TYPE_EAPOL 0x02 + * QDF_NBUF_PKT_TRAC_TYPE_DHCP 0x04 + * QDF_NBUF_PKT_TRAC_TYPE_ARP 0x10 + * + * Related: None + * + * Supported Feature: STA, SAP + * + * Usage: Internal + * + * + */ +#define CFG_DP_PROTO_EVENT_BITMAP \ + CFG_INI_UINT("dp_proto_event_bitmap", \ + 0, 0x17, 0x17, \ + CFG_VALUE_OR_DEFAULT, \ + "Control for which protocol type diag log should be sent") + +#define CFG_DP_CONFIG_DP_TRACE_ALL \ + CFG(CFG_DP_ENABLE_DP_TRACE) \ + CFG(CFG_DP_DP_TRACE_CONFIG) \ + CFG(CFG_DP_PROTO_EVENT_BITMAP) +#else +#define CFG_DP_CONFIG_DP_TRACE_ALL +#endif + +#ifdef WLAN_NUD_TRACKING +/* + * + * gEnableNUDTracking - Will enable or disable NUD tracking within driver + * @Min: 0 + * @Max: 3 + * @Default: 2 + * + * This ini is used to specify the behaviour of the driver for NUD tracking. + * If the ini value is:- + * 0: Driver will not track the NUD failures, and ignore the same. + * 1: Driver will track the NUD failures and if honoured will disconnect from + * the connected BSSID. + * 2: Driver will track the NUD failures and if honoured will roam away from + * the connected BSSID to a new BSSID to retain the data connectivity. + * 3: Driver will try to roam to a new AP but if roam fails, disconnect. + * Related: None + * + * Supported Feature: STA + * + * Usage: External + * + * + */ +#define CFG_DP_ENABLE_NUD_TRACKING \ + CFG_INI_UINT("gEnableNUDTracking", \ + 0, \ + 3, \ + 2, \ + CFG_VALUE_OR_DEFAULT, "Driver NUD tracking behaviour") + +#define CFG_DP_ENABLE_NUD_TRACKING_ALL \ + CFG(CFG_DP_ENABLE_NUD_TRACKING) +#else +#define CFG_DP_ENABLE_NUD_TRACKING_ALL +#endif + +#ifdef WLAN_SUPPORT_TXRX_HL_BUNDLE + +#define CFG_DP_HL_BUNDLE_HIGH_TH \ + CFG_INI_UINT( \ + "tx_bundle_high_threashold", \ + 0, \ + 70000, \ + 4330, \ + CFG_VALUE_OR_DEFAULT, \ + "tx bundle high threashold") + +#define CFG_DP_HL_BUNDLE_LOW_TH \ + CFG_INI_UINT( \ + "tx_bundle_low_threashold", \ + 0, \ + 70000, \ + 4000, \ + CFG_VALUE_OR_DEFAULT, \ + "tx bundle low threashold") + +#define CFG_DP_HL_BUNDLE_TIMER_VALUE \ + CFG_INI_UINT( \ + "tx_bundle_timer_in_ms", \ + 10, \ + 10000, \ + 100, \ + CFG_VALUE_OR_DEFAULT, \ + "tx bundle timer value in ms") + +#define CFG_DP_HL_BUNDLE_SIZE \ + CFG_INI_UINT( \ + "tx_bundle_size", \ + 0, \ + 64, \ + 16, \ + CFG_VALUE_OR_DEFAULT, \ + "tx bundle size") + +#endif + +#define WLAN_CFG_ICMP_REQ_TO_FW_MARK_ALL (-1) +#define WLAN_CFG_ICMP_REQ_TO_FW_MARK_INTERVAL 0 +#define WLAN_CFG_ICMP_REQ_TO_FW_MARK_INTERVAL_MIN (-1) +#define WLAN_CFG_ICMP_REQ_TO_FW_MARK_INTERVAL_MAX 100000 + +/* + * + * icmp_req_to_fw_mark_interval - Interval to mark the ICMP Request packet + * to be sent to FW. + * @Min: -1 + * @Max: 100000 + * @Default: 0 + * + * This ini is used to control DP Software to mark the ICMP request packets + * to be sent to FW at certain interval (in milliseconds). + * The value 0 is used to disable marking of ICMP requests to be sent to FW. + * The value -1 is used to mark all the ICMP requests to be sent to FW. + * Any value greater than zero indicates the time interval (in milliseconds) + * at which ICMP requests are marked to be sent to FW. + * + * Supported modes: All modes + * + * Usage: External + * + * + */ +#define CFG_DP_ICMP_REQ_TO_FW_MARK_INTERVAL \ + CFG_INI_INT("icmp_req_to_fw_mark_interval", \ + WLAN_CFG_ICMP_REQ_TO_FW_MARK_INTERVAL_MIN, \ + WLAN_CFG_ICMP_REQ_TO_FW_MARK_INTERVAL_MAX, \ + WLAN_CFG_ICMP_REQ_TO_FW_MARK_INTERVAL, \ + CFG_VALUE_OR_DEFAULT, \ + "Interval to mark ICMP Request packets to be sent to FW") + +/*TODO Flow control part to be moved to DP later*/ + +#ifdef WLAN_FEATURE_DP_BUS_BANDWIDTH +#define CFG_DP_BUS_BANDWIDTH \ + CFG(CFG_DP_BUS_BANDWIDTH_ULTRA_HIGH_THRESHOLD) \ + CFG(CFG_DP_BUS_BANDWIDTH_VERY_HIGH_THRESHOLD) \ + CFG(CFG_DP_BUS_BANDWIDTH_DBS_THRESHOLD) \ + CFG(CFG_DP_BUS_BANDWIDTH_HIGH_THRESHOLD) \ + CFG(CFG_DP_BUS_BANDWIDTH_MEDIUM_THRESHOLD) \ + CFG(CFG_DP_BUS_BANDWIDTH_LOW_THRESHOLD) \ + CFG(CFG_DP_BUS_BANDWIDTH_COMPUTE_INTERVAL) \ + CFG(CFG_DP_ENABLE_TCP_LIMIT_OUTPUT) \ + CFG(CFG_DP_ENABLE_TCP_ADV_WIN_SCALE) \ + CFG(CFG_DP_ENABLE_TCP_DELACK) \ + CFG(CFG_DP_TCP_DELACK_THRESHOLD_HIGH) \ + CFG(CFG_DP_TCP_DELACK_THRESHOLD_LOW) \ + CFG(CFG_DP_TCP_DELACK_TIMER_COUNT) \ + CFG(CFG_DP_TCP_TX_HIGH_TPUT_THRESHOLD) \ + CFG(CFG_DP_BUS_LOW_BW_CNT_THRESHOLD) \ + CFG(CFG_DP_BUS_HANDLE_LATENCY_CRITICAL_CLIENTS) + +#else +#define CFG_DP_BUS_BANDWIDTH +#endif + +#ifdef QCA_SUPPORT_TXRX_DRIVER_TCP_DEL_ACK +#define CFG_DP_DRIVER_TCP_DELACK \ + CFG(CFG_DP_DRIVER_TCP_DELACK_HIGH_THRESHOLD) \ + CFG(CFG_DP_DRIVER_TCP_DELACK_LOW_THRESHOLD) \ + CFG(CFG_DP_DRIVER_TCP_DELACK_TIMER_VALUE) \ + CFG(CFG_DP_DRIVER_TCP_DELACK_PKT_CNT) \ + CFG(CFG_DP_DRIVER_TCP_DELACK_ENABLE) +#else +#define CFG_DP_DRIVER_TCP_DELACK +#endif + +#ifdef WLAN_SUPPORT_TXRX_HL_BUNDLE +#define CFG_DP_HL_BUNDLE \ + CFG(CFG_DP_HL_BUNDLE_HIGH_TH) \ + CFG(CFG_DP_HL_BUNDLE_LOW_TH) \ + CFG(CFG_DP_HL_BUNDLE_TIMER_VALUE) \ + CFG(CFG_DP_HL_BUNDLE_SIZE) +#else +#define CFG_DP_HL_BUNDLE +#endif + +#define CFG_DP_ALL \ + CFG(CFG_DP_RX_THREAD_CPU_MASK) \ + CFG(CFG_DP_RX_THREAD_UL_CPU_MASK) \ + CFG(CFG_DP_RPS_RX_QUEUE_CPU_MAP_LIST) \ + CFG(CFG_DP_TX_ORPHAN_ENABLE) \ + CFG(CFG_DP_RX_MODE) \ + CFG(CFG_DP_TX_COMP_LOOP_PKT_LIMIT)\ + CFG(CFG_DP_RX_REAP_LOOP_PKT_LIMIT)\ + CFG(CFG_DP_RX_HP_OOS_UPDATE_LIMIT)\ + CFG(CFG_DP_RX_SOFTIRQ_MAX_YIELD_TIME_NS)\ + CFG(CFG_DP_CE_SERVICE_MAX_RX_IND_FLUSH) \ + CFG(CFG_DP_CE_SERVICE_MAX_YIELD_TIME) \ + CFG(CFG_DP_ENABLE_TCP_PARAM_UPDATE) \ + CFG(CFG_DP_FILTER_MULTICAST_REPLAY) \ + CFG(CFG_DP_RX_WAKELOCK_TIMEOUT) \ + CFG(CFG_DP_NUM_DP_RX_THREADS) \ + CFG(CFG_DP_ICMP_REQ_TO_FW_MARK_INTERVAL) \ + CFG_DP_ENABLE_FASTPATH_ALL \ + CFG_DP_BUS_BANDWIDTH \ + CFG_DP_DRIVER_TCP_DELACK \ + CFG_DP_ENABLE_NUD_TRACKING_ALL \ + CFG_DP_CONFIG_DP_TRACE_ALL \ + CFG_DP_HL_BUNDLE + #endif /* WLAN_DP_CFG_H__ */ diff --git a/components/dp/dispatcher/inc/wlan_dp_public_struct.h b/components/dp/dispatcher/inc/wlan_dp_public_struct.h index 885b895fd7..7e0825cd34 100644 --- a/components/dp/dispatcher/inc/wlan_dp_public_struct.h +++ b/components/dp/dispatcher/inc/wlan_dp_public_struct.h @@ -51,6 +51,14 @@ #define NUM_TX_QUEUES (4 * TX_QUEUES_PER_AC) #endif +#ifndef NUM_CPUS +#ifdef QCA_CONFIG_SMP +#define NUM_CPUS NR_CPUS +#else +#define NUM_CPUS 1 +#endif +#endif + /** * struct dp_arp_stats - arp debug stats count * @tx_arp_req_count: no. of arp req received from network stack @@ -222,6 +230,52 @@ struct dp_rsp_stats { uint32_t icmpv4_rsp_recvd; }; +struct dp_tx_rx_stats { + struct { + /* start_xmit stats */ + __u32 tx_called; + __u32 tx_dropped; + __u32 tx_orphaned; + __u32 tx_classified_ac[WLAN_MAX_AC]; + __u32 tx_dropped_ac[WLAN_MAX_AC]; +#ifdef TX_MULTIQ_PER_AC + /* Neither valid socket nor skb->hash */ + uint32_t inv_sk_and_skb_hash; + /* skb->hash already calculated */ + uint32_t qselect_existing_skb_hash; + /* valid tx queue id in socket */ + uint32_t qselect_sk_tx_map; + /* skb->hash calculated in select queue */ + uint32_t qselect_skb_hash_calc; +#endif + /* rx stats */ + __u32 rx_packets; + __u32 rx_dropped; + __u32 rx_delivered; + __u32 rx_refused; + } per_cpu[NUM_CPUS]; + + qdf_atomic_t rx_usolict_arp_n_mcast_drp; + + /* rx gro */ + __u32 rx_aggregated; + __u32 rx_gro_dropped; + __u32 rx_non_aggregated; + __u32 rx_gro_flush_skip; + __u32 rx_gro_low_tput_flush; + + /* txflow stats */ + bool is_txflow_paused; + __u32 txflow_pause_cnt; + __u32 txflow_unpause_cnt; + __u32 txflow_timer_cnt; + + /*tx timeout stats*/ + __u32 tx_timeout_cnt; + __u32 cont_txtimeout_cnt; + u64 last_txtimeout; +}; + /** * struct dp_dhcp_ind - DHCP Start/Stop indication message * @dhcp_start: Is DHCP start idication diff --git a/components/dp/dispatcher/inc/wlan_dp_ucfg_api.h b/components/dp/dispatcher/inc/wlan_dp_ucfg_api.h index 8d9fbc5a92..8180d55c04 100644 --- a/components/dp/dispatcher/inc/wlan_dp_ucfg_api.h +++ b/components/dp/dispatcher/inc/wlan_dp_ucfg_api.h @@ -716,4 +716,20 @@ void ucfg_dp_register_hdd_callbacks(struct wlan_objmgr_psoc *psoc, */ void ucfg_dp_register_event_handler(struct wlan_objmgr_psoc *psoc, struct wlan_dp_psoc_nb_ops *cb_obj); + +/** + * ucfg_dp_get_bus_bw_compute_interval() - Get bus bandwidth compute interval + * @psoc: psoc handle + * + * Returns: Bus bandwidth compute interval + */ +uint32_t ucfg_dp_get_bus_bw_compute_interval(struct wlan_objmgr_psoc *psoc); + +/** + * ucfg_dp_get_current_throughput_level() - get current bandwidth level + * @psoc: psoc handle + * + * Return: current bandwidth level + */ +int ucfg_dp_get_current_throughput_level(struct wlan_objmgr_psoc *psoc); #endif /* _WLAN_DP_UCFG_API_H_ */ diff --git a/components/dp/dispatcher/src/wlan_dp_ucfg_api.c b/components/dp/dispatcher/src/wlan_dp_ucfg_api.c index ebb07826cb..29583752c1 100644 --- a/components/dp/dispatcher/src/wlan_dp_ucfg_api.c +++ b/components/dp/dispatcher/src/wlan_dp_ucfg_api.c @@ -971,6 +971,16 @@ void ucfg_dp_set_dump_dp_trace(uint16_t cmd_type, uint16_t count) dp_set_dump_dp_trace(cmd_type, count); } +int ucfg_dp_get_current_throughput_level(struct wlan_objmgr_psoc *psoc) +{ + struct wlan_dp_psoc_context *dp_ctx = dp_psoc_get_priv(psoc); + + if (!dp_ctx) + return 0; + + return dp_get_current_throughput_level(dp_ctx); +} + QDF_STATUS ucfg_dp_req_get_arp_stats(struct wlan_objmgr_psoc *psoc, struct dp_get_arp_stats_params *params) @@ -1048,3 +1058,14 @@ void ucfg_dp_register_event_handler(struct wlan_objmgr_psoc *psoc, dp_ctx->nb_ops.osif_dp_get_arp_stats_evt = cb_obj->osif_dp_get_arp_stats_evt; } + +uint32_t ucfg_dp_get_bus_bw_compute_interval(struct wlan_objmgr_psoc *psoc) +{ + struct wlan_dp_psoc_context *dp_ctx = dp_psoc_get_priv(psoc); + + if (!dp_ctx) { + dp_err("DP ctx is NULL"); + return 0; + } + return dp_ctx->dp_cfg.bus_bw_compute_interval; +}