Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e9c5a106 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'net-NETIF_F_GRO_HW'



Michael Chan says:

====================
Introduce NETIF_F_GRO_HW

Introduce NETIF_F_GRO_HW feature flag and convert drivers that support
hardware GRO to use the new flag.

v5:
- Documentation changes requested by Alexander Duyck.
- bnx2x changes requested by Manish Chopra to enable LRO by default, and
disable GRO_HW if disable_tpa module parameter is set.

v4:
- more changes requested by Alexander Duyck:
- check GRO_HW/GRO dependency in drivers's ndo_fix_features().
- Reverse the order of RXCSUM and GRO_HW dependency check in
netdev_fix_features().
- No propagation in netdev_disable_gro_hw().

v3:
- Let driver's ndo_fix_features() disable NETIF_F_LRO when NETIF_F_GRO_HW
is set instead of doing it in common netdev_fix_features().

v2:
- NETIF_F_GRO_HW flag propagation between upper and lower devices not
required (see patch 1).
- NETIF_F_GRO_HW depends on NETIF_F_GRO and NETIF_F_RXCSUM.
- Add dev_disable_gro_hw() to disable GRO_HW for generic XDP.
- Use ndo_fix_features() on all 3 drivers to drop GRO_HW when it is not
supported
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 398b841e 18c602de
Loading
Loading
Loading
Loading
+9 −0
Original line number Original line Diff line number Diff line
@@ -163,3 +163,12 @@ This requests that the NIC receive all possible frames, including errored
frames (such as bad FCS, etc).  This can be helpful when sniffing a link with
frames (such as bad FCS, etc).  This can be helpful when sniffing a link with
bad packets on it.  Some NICs may receive more packets if also put into normal
bad packets on it.  Some NICs may receive more packets if also put into normal
PROMISC mode.
PROMISC mode.

*  rx-gro-hw

This requests that the NIC enables Hardware GRO (generic receive offload).
Hardware GRO is basically the exact reverse of TSO, and is generally
stricter than Hardware LRO.  A packet stream merged by Hardware GRO must
be re-segmentable by GSO or TSO back to the exact original packet stream.
Hardware GRO is dependent on RXCSUM since every packet successfully merged
by hardware must also have the checksum verified by hardware.
+12 −12
Original line number Original line Diff line number Diff line
@@ -2482,8 +2482,7 @@ static void bnx2x_bz_fp(struct bnx2x *bp, int index)
	 */
	 */
	if (bp->dev->features & NETIF_F_LRO)
	if (bp->dev->features & NETIF_F_LRO)
		fp->mode = TPA_MODE_LRO;
		fp->mode = TPA_MODE_LRO;
	else if (bp->dev->features & NETIF_F_GRO &&
	else if (bp->dev->features & NETIF_F_GRO_HW)
		 bnx2x_mtu_allows_gro(bp->dev->mtu))
		fp->mode = TPA_MODE_GRO;
		fp->mode = TPA_MODE_GRO;
	else
	else
		fp->mode = TPA_MODE_DISABLED;
		fp->mode = TPA_MODE_DISABLED;
@@ -4874,6 +4873,9 @@ int bnx2x_change_mtu(struct net_device *dev, int new_mtu)
	 */
	 */
	dev->mtu = new_mtu;
	dev->mtu = new_mtu;


	if (!bnx2x_mtu_allows_gro(new_mtu))
		dev->features &= ~NETIF_F_GRO_HW;

	if (IS_PF(bp) && SHMEM2_HAS(bp, curr_cfg))
	if (IS_PF(bp) && SHMEM2_HAS(bp, curr_cfg))
		SHMEM2_WR(bp, curr_cfg, CURR_CFG_MET_OS);
		SHMEM2_WR(bp, curr_cfg, CURR_CFG_MET_OS);


@@ -4903,10 +4905,13 @@ netdev_features_t bnx2x_fix_features(struct net_device *dev,
	}
	}


	/* TPA requires Rx CSUM offloading */
	/* TPA requires Rx CSUM offloading */
	if (!(features & NETIF_F_RXCSUM)) {
	if (!(features & NETIF_F_RXCSUM))
		features &= ~NETIF_F_LRO;

	if (!(features & NETIF_F_GRO) || !bnx2x_mtu_allows_gro(dev->mtu))
		features &= ~NETIF_F_GRO_HW;
	if (features & NETIF_F_GRO_HW)
		features &= ~NETIF_F_LRO;
		features &= ~NETIF_F_LRO;
		features &= ~NETIF_F_GRO;
	}


	return features;
	return features;
}
}
@@ -4933,12 +4938,7 @@ int bnx2x_set_features(struct net_device *dev, netdev_features_t features)
		}
		}
	}
	}


	/* if GRO is changed while LRO is enabled, don't force a reload */
	/* Don't care about GRO changes */
	if ((changes & NETIF_F_GRO) && (features & NETIF_F_LRO))
		changes &= ~NETIF_F_GRO;

	/* if GRO is changed while HW TPA is off, don't force a reload */
	if ((changes & NETIF_F_GRO) && bp->disable_tpa)
	changes &= ~NETIF_F_GRO;
	changes &= ~NETIF_F_GRO;


	if (changes)
	if (changes)
+5 −3
Original line number Original line Diff line number Diff line
@@ -12400,8 +12400,8 @@ static int bnx2x_init_bp(struct bnx2x *bp)


	/* Set TPA flags */
	/* Set TPA flags */
	if (bp->disable_tpa) {
	if (bp->disable_tpa) {
		bp->dev->hw_features &= ~NETIF_F_LRO;
		bp->dev->hw_features &= ~(NETIF_F_LRO | NETIF_F_GRO_HW);
		bp->dev->features &= ~NETIF_F_LRO;
		bp->dev->features &= ~(NETIF_F_LRO | NETIF_F_GRO_HW);
	}
	}


	if (CHIP_IS_E1(bp))
	if (CHIP_IS_E1(bp))
@@ -13273,7 +13273,7 @@ static int bnx2x_init_dev(struct bnx2x *bp, struct pci_dev *pdev,


	dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
	dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
		NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6 |
		NETIF_F_TSO | NETIF_F_TSO_ECN | NETIF_F_TSO6 |
		NETIF_F_RXCSUM | NETIF_F_LRO | NETIF_F_GRO |
		NETIF_F_RXCSUM | NETIF_F_LRO | NETIF_F_GRO | NETIF_F_GRO_HW |
		NETIF_F_RXHASH | NETIF_F_HW_VLAN_CTAG_TX;
		NETIF_F_RXHASH | NETIF_F_HW_VLAN_CTAG_TX;
	if (!chip_is_e1x) {
	if (!chip_is_e1x) {
		dev->hw_features |= NETIF_F_GSO_GRE | NETIF_F_GSO_GRE_CSUM |
		dev->hw_features |= NETIF_F_GSO_GRE | NETIF_F_GSO_GRE_CSUM |
@@ -13309,6 +13309,8 @@ static int bnx2x_init_dev(struct bnx2x *bp, struct pci_dev *pdev,


	dev->features |= dev->hw_features | NETIF_F_HW_VLAN_CTAG_RX;
	dev->features |= dev->hw_features | NETIF_F_HW_VLAN_CTAG_RX;
	dev->features |= NETIF_F_HIGHDMA;
	dev->features |= NETIF_F_HIGHDMA;
	if (dev->features & NETIF_F_LRO)
		dev->features &= ~NETIF_F_GRO_HW;


	/* Add Loopback capability to the device */
	/* Add Loopback capability to the device */
	dev->hw_features |= NETIF_F_LOOPBACK;
	dev->hw_features |= NETIF_F_LOOPBACK;
+20 −7
Original line number Original line Diff line number Diff line
@@ -2755,7 +2755,7 @@ void bnxt_set_tpa_flags(struct bnxt *bp)
		return;
		return;
	if (bp->dev->features & NETIF_F_LRO)
	if (bp->dev->features & NETIF_F_LRO)
		bp->flags |= BNXT_FLAG_LRO;
		bp->flags |= BNXT_FLAG_LRO;
	if (bp->dev->features & NETIF_F_GRO)
	else if (bp->dev->features & NETIF_F_GRO_HW)
		bp->flags |= BNXT_FLAG_GRO;
		bp->flags |= BNXT_FLAG_GRO;
}
}


@@ -2843,10 +2843,10 @@ int bnxt_set_rx_skb_mode(struct bnxt *bp, bool page_mode)
			min_t(u16, bp->max_mtu, BNXT_MAX_PAGE_MODE_MTU);
			min_t(u16, bp->max_mtu, BNXT_MAX_PAGE_MODE_MTU);
		bp->flags &= ~BNXT_FLAG_AGG_RINGS;
		bp->flags &= ~BNXT_FLAG_AGG_RINGS;
		bp->flags |= BNXT_FLAG_NO_AGG_RINGS | BNXT_FLAG_RX_PAGE_MODE;
		bp->flags |= BNXT_FLAG_NO_AGG_RINGS | BNXT_FLAG_RX_PAGE_MODE;
		bp->dev->hw_features &= ~NETIF_F_LRO;
		bp->dev->features &= ~NETIF_F_LRO;
		bp->rx_dir = DMA_BIDIRECTIONAL;
		bp->rx_dir = DMA_BIDIRECTIONAL;
		bp->rx_skb_func = bnxt_rx_page_skb;
		bp->rx_skb_func = bnxt_rx_page_skb;
		/* Disable LRO or GRO_HW */
		netdev_update_features(bp->dev);
	} else {
	} else {
		bp->dev->max_mtu = bp->max_mtu;
		bp->dev->max_mtu = bp->max_mtu;
		bp->flags &= ~BNXT_FLAG_RX_PAGE_MODE;
		bp->flags &= ~BNXT_FLAG_RX_PAGE_MODE;
@@ -6788,6 +6788,15 @@ static netdev_features_t bnxt_fix_features(struct net_device *dev,
	if ((features & NETIF_F_NTUPLE) && !bnxt_rfs_capable(bp))
	if ((features & NETIF_F_NTUPLE) && !bnxt_rfs_capable(bp))
		features &= ~NETIF_F_NTUPLE;
		features &= ~NETIF_F_NTUPLE;


	if (bp->flags & BNXT_FLAG_NO_AGG_RINGS)
		features &= ~(NETIF_F_LRO | NETIF_F_GRO_HW);

	if (!(features & NETIF_F_GRO))
		features &= ~NETIF_F_GRO_HW;

	if (features & NETIF_F_GRO_HW)
		features &= ~NETIF_F_LRO;

	/* Both CTAG and STAG VLAN accelaration on the RX side have to be
	/* Both CTAG and STAG VLAN accelaration on the RX side have to be
	 * turned on or off together.
	 * turned on or off together.
	 */
	 */
@@ -6821,9 +6830,9 @@ static int bnxt_set_features(struct net_device *dev, netdev_features_t features)
	bool update_tpa = false;
	bool update_tpa = false;


	flags &= ~BNXT_FLAG_ALL_CONFIG_FEATS;
	flags &= ~BNXT_FLAG_ALL_CONFIG_FEATS;
	if ((features & NETIF_F_GRO) && !BNXT_CHIP_TYPE_NITRO_A0(bp))
	if (features & NETIF_F_GRO_HW)
		flags |= BNXT_FLAG_GRO;
		flags |= BNXT_FLAG_GRO;
	if (features & NETIF_F_LRO)
	else if (features & NETIF_F_LRO)
		flags |= BNXT_FLAG_LRO;
		flags |= BNXT_FLAG_LRO;


	if (bp->flags & BNXT_FLAG_NO_AGG_RINGS)
	if (bp->flags & BNXT_FLAG_NO_AGG_RINGS)
@@ -7924,8 +7933,8 @@ static int bnxt_get_dflt_rings(struct bnxt *bp, int *max_rx, int *max_tx,
		if (rc)
		if (rc)
			return rc;
			return rc;
		bp->flags |= BNXT_FLAG_NO_AGG_RINGS;
		bp->flags |= BNXT_FLAG_NO_AGG_RINGS;
		bp->dev->hw_features &= ~NETIF_F_LRO;
		bp->dev->hw_features &= ~(NETIF_F_LRO | NETIF_F_GRO_HW);
		bp->dev->features &= ~NETIF_F_LRO;
		bp->dev->features &= ~(NETIF_F_LRO | NETIF_F_GRO_HW);
		bnxt_set_ring_params(bp);
		bnxt_set_ring_params(bp);
	}
	}


@@ -8108,7 +8117,11 @@ static int bnxt_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
	dev->vlan_features = dev->hw_features | NETIF_F_HIGHDMA;
	dev->vlan_features = dev->hw_features | NETIF_F_HIGHDMA;
	dev->hw_features |= NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_TX |
	dev->hw_features |= NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_TX |
			    NETIF_F_HW_VLAN_STAG_RX | NETIF_F_HW_VLAN_STAG_TX;
			    NETIF_F_HW_VLAN_STAG_RX | NETIF_F_HW_VLAN_STAG_TX;
	if (!BNXT_CHIP_TYPE_NITRO_A0(bp))
		dev->hw_features |= NETIF_F_GRO_HW;
	dev->features |= dev->hw_features | NETIF_F_HIGHDMA;
	dev->features |= dev->hw_features | NETIF_F_HIGHDMA;
	if (dev->features & NETIF_F_GRO_HW)
		dev->features &= ~NETIF_F_LRO;
	dev->priv_flags |= IFF_UNICAST_FLT;
	dev->priv_flags |= IFF_UNICAST_FLT;


#ifdef CONFIG_BNXT_SRIOV
#ifdef CONFIG_BNXT_SRIOV
+2 −0
Original line number Original line Diff line number Diff line
@@ -494,6 +494,8 @@ int qede_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, u16 vid);
void qede_vlan_mark_nonconfigured(struct qede_dev *edev);
void qede_vlan_mark_nonconfigured(struct qede_dev *edev);
int qede_configure_vlan_filters(struct qede_dev *edev);
int qede_configure_vlan_filters(struct qede_dev *edev);


netdev_features_t qede_fix_features(struct net_device *dev,
				    netdev_features_t features);
int qede_set_features(struct net_device *dev, netdev_features_t features);
int qede_set_features(struct net_device *dev, netdev_features_t features);
void qede_set_rx_mode(struct net_device *ndev);
void qede_set_rx_mode(struct net_device *ndev);
void qede_config_rx_mode(struct net_device *ndev);
void qede_config_rx_mode(struct net_device *ndev);
Loading