qcacld-3.0: Add GRO support for STA mode
Add GRO support and make it configurable through INI(GROEnable).
GRO and LRO are mutually exclusive. Only one of them can be enabled.
And disable GRO during following conditions
1) Low TPUT scenario
2) Concurrency cases
3) For Rx packets when Peer is not connected
Change-Id: I15535827a03953231670d4138235c4876b16e045
CRs-Fixed: 2098772
diff --git a/core/hdd/src/wlan_hdd_tx_rx.c b/core/hdd/src/wlan_hdd_tx_rx.c
index 9f7abd1..9c19fa1 100644
--- a/core/hdd/src/wlan_hdd_tx_rx.c
+++ b/core/hdd/src/wlan_hdd_tx_rx.c
@@ -55,6 +55,8 @@
#include "wlan_hdd_power.h"
#include "wlan_hdd_cfg80211.h"
#include <wlan_hdd_tsf.h>
+#include <net/tcp.h>
+#include "wma_api.h"
#include "wlan_hdd_nud_tracking.h"
@@ -1522,6 +1524,201 @@
return false;
}
+#ifdef RECEIVE_OFFLOAD
+/**
+ * hdd_resolve_rx_ol_mode() - Resolve Rx offload method, LRO or GRO
+ * @hdd_ctx: pointer to HDD Station Context
+ *
+ * Return: None
+ */
+static void hdd_resolve_rx_ol_mode(struct hdd_context *hdd_ctx)
+{
+ if (!(hdd_ctx->config->lro_enable ^
+ hdd_ctx->config->gro_enable)) {
+ hdd_ctx->config->lro_enable && hdd_ctx->config->gro_enable ?
+ hdd_err("Can't enable both LRO and GRO, disabling Rx offload") :
+ hdd_debug("LRO and GRO both are disabled");
+ hdd_ctx->ol_enable = 0;
+ } else if (hdd_ctx->config->lro_enable) {
+ hdd_debug("Rx offload LRO is enabled");
+ hdd_ctx->ol_enable = CFG_LRO_ENABLED;
+ } else {
+ hdd_debug("Rx offload GRO is enabled");
+ hdd_ctx->ol_enable = CFG_GRO_ENABLED;
+ }
+}
+
+/**
+ * hdd_gro_rx() - Handle Rx procesing via GRO
+ * @adapter: pointer to adapter context
+ * @skb: pointer to sk_buff
+ *
+ * Return: QDF_STATUS_SUCCESS if processed via GRO or non zero return code
+ */
+static QDF_STATUS hdd_gro_rx(struct hdd_adapter *adapter, struct sk_buff *skb)
+{
+ struct napi_struct *napi;
+ struct qca_napi_data *napid;
+ QDF_STATUS status = QDF_STATUS_E_FAILURE;
+
+ /* Only enabling it for STA mode like LRO today */
+ if (QDF_STA_MODE != adapter->device_mode)
+ return QDF_STATUS_E_NOSUPPORT;
+
+ napid = hdd_napi_get_all();
+ napi = hif_get_napi(QDF_NBUF_CB_RX_CTX_ID(skb), napid);
+ skb_set_hash(skb, QDF_NBUF_CB_RX_FLOW_ID(skb), PKT_HASH_TYPE_L4);
+
+ if (GRO_DROP != napi_gro_receive(napi, skb))
+ status = QDF_STATUS_SUCCESS;
+
+ return status;
+}
+
+/**
+ * hdd_register_rx_ol() - Register LRO/GRO rx processing callbacks
+ *
+ * Return: none
+ */
+static void hdd_register_rx_ol(void)
+{
+ struct hdd_context *hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
+
+ if (!hdd_ctx)
+ hdd_err("HDD context is NULL");
+
+ if (hdd_ctx->ol_enable == CFG_LRO_ENABLED) {
+ /* Register the flush callback */
+ hdd_ctx->receive_offload_cb = hdd_lro_rx;
+ hdd_debug("LRO is enabled");
+ } else if (hdd_ctx->ol_enable == CFG_GRO_ENABLED) {
+ hdd_ctx->receive_offload_cb = hdd_gro_rx;
+ hdd_debug("GRO is enabled");
+ }
+}
+
+int hdd_rx_ol_init(struct hdd_context *hdd_ctx)
+{
+ struct cdp_lro_hash_config lro_config = {0};
+
+ hdd_resolve_rx_ol_mode(hdd_ctx);
+
+ hdd_register_rx_ol();
+
+ /*
+ * This will enable flow steering and Toeplitz hash
+ * So enable it for LRO or GRO processing.
+ */
+ if (hdd_napi_enabled(HDD_NAPI_ANY) == 0) {
+ hdd_warn("NAPI is disabled");
+ return 0;
+ }
+
+ lro_config.lro_enable = 1;
+ lro_config.tcp_flag = TCPHDR_ACK;
+ lro_config.tcp_flag_mask = TCPHDR_FIN | TCPHDR_SYN | TCPHDR_RST |
+ TCPHDR_ACK | TCPHDR_URG | TCPHDR_ECE | TCPHDR_CWR;
+
+ get_random_bytes(lro_config.toeplitz_hash_ipv4,
+ (sizeof(lro_config.toeplitz_hash_ipv4[0]) *
+ LRO_IPV4_SEED_ARR_SZ));
+
+ get_random_bytes(lro_config.toeplitz_hash_ipv6,
+ (sizeof(lro_config.toeplitz_hash_ipv6[0]) *
+ LRO_IPV6_SEED_ARR_SZ));
+
+ if (0 != wma_lro_init(&lro_config)) {
+ hdd_err("Failed to send LRO configuration!");
+ hdd_ctx->ol_enable = 0;
+ return -EAGAIN;
+ }
+
+ return 0;
+}
+
+void hdd_disable_rx_ol_in_concurrency(bool disable)
+{
+ struct hdd_context *hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
+
+ if (!hdd_ctx) {
+ hdd_err("hdd_ctx is NULL");
+ return;
+ }
+
+ if (disable) {
+ if (hdd_ctx->en_tcp_delack_no_lro) {
+ struct wlan_rx_tp_data rx_tp_data;
+
+ hdd_info("Enable TCP delack as LRO disabled in concurrency");
+ rx_tp_data.rx_tp_flags = TCP_DEL_ACK_IND;
+ rx_tp_data.level = GET_CUR_RX_LVL(hdd_ctx);
+ wlan_hdd_send_svc_nlink_msg(hdd_ctx->radio_index,
+ WLAN_SVC_WLAN_TP_IND,
+ &rx_tp_data,
+ sizeof(rx_tp_data));
+ hdd_ctx->en_tcp_delack_no_lro = 1;
+ }
+ qdf_atomic_set(&hdd_ctx->disable_lro_in_concurrency, 1);
+ } else {
+ if (hdd_ctx->en_tcp_delack_no_lro) {
+ hdd_info("Disable TCP delack as LRO is enabled");
+ hdd_ctx->en_tcp_delack_no_lro = 0;
+ hdd_reset_tcp_delack(hdd_ctx);
+ }
+ qdf_atomic_set(&hdd_ctx->disable_lro_in_concurrency, 0);
+ }
+}
+
+void hdd_disable_rx_ol_for_low_tput(struct hdd_context *hdd_ctx, bool disable)
+{
+ if (disable)
+ qdf_atomic_set(&hdd_ctx->disable_lro_in_low_tput, 1);
+ else
+ qdf_atomic_set(&hdd_ctx->disable_lro_in_low_tput, 0);
+}
+
+/**
+ * hdd_can_handle_receive_offload() - Check for dynamic disablement
+ * @hdd_ctx: hdd context
+ * @skb: pointer to sk_buff which will be processed by Rx OL
+ *
+ * Check for dynamic disablement of Rx offload
+ *
+ * Return: false if we cannot process otherwise true
+ */
+static bool hdd_can_handle_receive_offload(struct hdd_context *hdd_ctx,
+ struct sk_buff *skb)
+{
+ if (!QDF_NBUF_CB_RX_TCP_PROTO(skb) ||
+ qdf_atomic_read(&hdd_ctx->disable_lro_in_concurrency) ||
+ QDF_NBUF_CB_RX_PEER_CACHED_FRM(skb) ||
+ qdf_atomic_read(&hdd_ctx->disable_lro_in_low_tput))
+ return false;
+ else
+ return true;
+}
+#else /* RECEIVE_OFFLOAD */
+static bool hdd_can_handle_receive_offload(struct hdd_context *hdd_ctx,
+ struct sk_buff *skb)
+{
+ return false;
+}
+
+int hdd_rx_ol_init(struct hdd_context *hdd_ctx)
+{
+ hdd_err("Rx_OL, LRO/GRO not supported");
+ return -EPERM;
+}
+
+void hdd_disable_rx_ol_in_concurrency(bool disable)
+{
+}
+
+void hdd_disable_rx_ol_for_low_tput(struct hdd_context *hdd_ctx, bool disable)
+{
+}
+#endif /* RECEIVE_OFFLOAD */
+
#ifdef WLAN_FEATURE_TSF_PLUS
static inline void hdd_tsf_timestamp_rx(struct hdd_context *hdd_ctx,
qdf_nbuf_t netbuf,
@@ -1556,7 +1753,8 @@
{
struct hdd_adapter *adapter = NULL;
struct hdd_context *hdd_ctx = NULL;
- int rxstat;
+ int rxstat = 0;
+ QDF_STATUS rx_ol_status = QDF_STATUS_E_FAILURE;
struct sk_buff *skb = NULL;
struct sk_buff *next = NULL;
struct hdd_station_ctx *sta_ctx = NULL;
@@ -1712,40 +1910,21 @@
hdd_tsf_timestamp_rx(hdd_ctx, skb, ktime_to_us(skb->tstamp));
- if (HDD_LRO_NO_RX ==
- hdd_lro_rx(hdd_ctx, adapter, skb)) {
+ if (hdd_can_handle_receive_offload(hdd_ctx, skb) &&
+ hdd_ctx->receive_offload_cb)
+ rx_ol_status = hdd_ctx->receive_offload_cb(adapter,
+ skb);
+
+ if (rx_ol_status != QDF_STATUS_SUCCESS) {
if (hdd_napi_enabled(HDD_NAPI_ANY) &&
!hdd_ctx->enable_rxthread &&
!QDF_NBUF_CB_RX_PEER_CACHED_FRM(skb))
rxstat = netif_receive_skb(skb);
else
rxstat = netif_rx_ni(skb);
+ }
- if (NET_RX_SUCCESS == rxstat) {
- ++adapter->hdd_stats.tx_rx_stats.
- rx_delivered[cpu_index];
- if (track_arp)
- ++adapter->hdd_stats.hdd_arp_stats.
- rx_delivered;
- /* track connectivity stats */
- if (adapter->pkt_type_bitmap)
- hdd_tx_rx_collect_connectivity_stats_info(
- skb, adapter,
- PKT_TYPE_RX_DELIVERED,
- &pkt_type);
- } else {
- ++adapter->hdd_stats.tx_rx_stats.
- rx_refused[cpu_index];
- if (track_arp)
- ++adapter->hdd_stats.hdd_arp_stats.
- rx_refused;
- /* track connectivity stats */
- if (adapter->pkt_type_bitmap)
- hdd_tx_rx_collect_connectivity_stats_info(
- skb, adapter,
- PKT_TYPE_RX_REFUSED, &pkt_type);
- }
- } else {
+ if (!rxstat) {
++adapter->hdd_stats.tx_rx_stats.
rx_delivered[cpu_index];
if (track_arp)
@@ -1756,6 +1935,17 @@
hdd_tx_rx_collect_connectivity_stats_info(
skb, adapter,
PKT_TYPE_RX_DELIVERED, &pkt_type);
+ } else {
+ ++adapter->hdd_stats.tx_rx_stats.rx_refused[cpu_index];
+ if (track_arp)
+ ++adapter->hdd_stats.hdd_arp_stats.rx_refused;
+
+ /* track connectivity stats */
+ if (adapter->pkt_type_bitmap)
+ hdd_tx_rx_collect_connectivity_stats_info(
+ skb, adapter,
+ PKT_TYPE_RX_REFUSED, &pkt_type);
+
}
}