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

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

Merge branch 'sfc-more-encap-offloads' 



Edward Cree says:

====================
sfc: more encap offloads

This patch series adds support for RX checksum offload of encapsulated packets.
It also adds support for configuring the hardware's lists of UDP ports used for
VXLAN and GENEVE encapsulation offloads.  Since changing these lists causes the
MC to reboot, the driver has been hardened against reboots, which used to be
considered an exceptional occurrence but are now normal.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents df6dd79b e5fbd977

drivers/net/ethernet/sfc/bitfield.h

+3 −0
Original line number Diff line number Diff line
@@ -433,6 +433,9 @@ typedef union efx_oword { 
		(oword).u64[1] = (from).u64[1] & (mask).u64[1];	\

	} while (0)



#define EFX_AND_QWORD(qword, from, mask)			\

		(qword).u64[0] = (from).u64[0] & (mask).u64[0]



#define EFX_OR_OWORD(oword, from, mask)				\

	do {							\

		(oword).u64[0] = (from).u64[0] | (mask).u64[0];	\

drivers/net/ethernet/sfc/ef10.c

+417 −12
Original line number Diff line number Diff line
@@ -132,6 +132,7 @@ static int efx_ef10_filter_add_vlan(struct efx_nic *efx, u16 vid); 
static void efx_ef10_filter_del_vlan_internal(struct efx_nic *efx,

					      struct efx_ef10_filter_vlan *vlan);

static void efx_ef10_filter_del_vlan(struct efx_nic *efx, u16 vid);

static int efx_ef10_set_udp_tnl_ports(struct efx_nic *efx, bool unloading);



static int efx_ef10_get_warm_boot_count(struct efx_nic *efx)

{
@@ -624,6 +625,8 @@ static int efx_ef10_probe(struct efx_nic *efx) 
	if (rc)

		goto fail2;



	mutex_init(&nic_data->udp_tunnels_lock);



	/* Reset (most) configuration for this function */

	rc = efx_mcdi_reset(efx, RESET_TYPE_ALL);

	if (rc)
@@ -712,6 +715,14 @@ static int efx_ef10_probe(struct efx_nic *efx) 
fail4:

	device_remove_file(&efx->pci_dev->dev, &dev_attr_link_control_flag);

fail3:

	efx_mcdi_detach(efx);



	mutex_lock(&nic_data->udp_tunnels_lock);

	memset(nic_data->udp_tunnels, 0, sizeof(nic_data->udp_tunnels));

	(void)efx_ef10_set_udp_tnl_ports(efx, true);

	mutex_unlock(&nic_data->udp_tunnels_lock);

	mutex_destroy(&nic_data->udp_tunnels_lock);



	efx_mcdi_fini(efx);

fail2:

	efx_nic_free_buffer(efx, &nic_data->mcdi_buf);
@@ -981,6 +992,15 @@ static void efx_ef10_remove(struct efx_nic *efx) 
	device_remove_file(&efx->pci_dev->dev, &dev_attr_primary_flag);

	device_remove_file(&efx->pci_dev->dev, &dev_attr_link_control_flag);



	efx_mcdi_detach(efx);



	memset(nic_data->udp_tunnels, 0, sizeof(nic_data->udp_tunnels));

	mutex_lock(&nic_data->udp_tunnels_lock);

	(void)efx_ef10_set_udp_tnl_ports(efx, true);

	mutex_unlock(&nic_data->udp_tunnels_lock);



	mutex_destroy(&nic_data->udp_tunnels_lock);



	efx_mcdi_fini(efx);

	efx_nic_free_buffer(efx, &nic_data->mcdi_buf);

	kfree(nic_data);
@@ -3154,13 +3174,103 @@ static void efx_ef10_handle_rx_abort(struct efx_rx_queue *rx_queue) 
	++efx_rx_queue_channel(rx_queue)->n_rx_nodesc_trunc;

}



static u16 efx_ef10_handle_rx_event_errors(struct efx_channel *channel,

					   unsigned int n_packets,

					   unsigned int rx_encap_hdr,

					   unsigned int rx_l3_class,

					   unsigned int rx_l4_class,

					   const efx_qword_t *event)

{

	struct efx_nic *efx = channel->efx;



	if (EFX_QWORD_FIELD(*event, ESF_DZ_RX_ECRC_ERR)) {

		if (!efx->loopback_selftest)

			channel->n_rx_eth_crc_err += n_packets;

		return EFX_RX_PKT_DISCARD;

	}

	if (EFX_QWORD_FIELD(*event, ESF_DZ_RX_IPCKSUM_ERR)) {

		if (unlikely(rx_encap_hdr != ESE_EZ_ENCAP_HDR_VXLAN &&

			     rx_l3_class != ESE_DZ_L3_CLASS_IP4 &&

			     rx_l3_class != ESE_DZ_L3_CLASS_IP4_FRAG &&

			     rx_l3_class != ESE_DZ_L3_CLASS_IP6 &&

			     rx_l3_class != ESE_DZ_L3_CLASS_IP6_FRAG))

			netdev_WARN(efx->net_dev,

				    "invalid class for RX_IPCKSUM_ERR: event="

				    EFX_QWORD_FMT "\n",

				    EFX_QWORD_VAL(*event));

		if (!efx->loopback_selftest)

			*(rx_encap_hdr ?

			  &channel->n_rx_outer_ip_hdr_chksum_err :

			  &channel->n_rx_ip_hdr_chksum_err) += n_packets;

		return 0;

	}

	if (EFX_QWORD_FIELD(*event, ESF_DZ_RX_TCPUDP_CKSUM_ERR)) {

		if (unlikely(rx_encap_hdr != ESE_EZ_ENCAP_HDR_VXLAN &&

			     ((rx_l3_class != ESE_DZ_L3_CLASS_IP4 &&

			       rx_l3_class != ESE_DZ_L3_CLASS_IP6) ||

			      (rx_l4_class != ESE_DZ_L4_CLASS_TCP &&

			       rx_l4_class != ESE_DZ_L4_CLASS_UDP))))

			netdev_WARN(efx->net_dev,

				    "invalid class for RX_TCPUDP_CKSUM_ERR: event="

				    EFX_QWORD_FMT "\n",

				    EFX_QWORD_VAL(*event));

		if (!efx->loopback_selftest)

			*(rx_encap_hdr ?

			  &channel->n_rx_outer_tcp_udp_chksum_err :

			  &channel->n_rx_tcp_udp_chksum_err) += n_packets;

		return 0;

	}

	if (EFX_QWORD_FIELD(*event, ESF_EZ_RX_IP_INNER_CHKSUM_ERR)) {

		if (unlikely(!rx_encap_hdr))

			netdev_WARN(efx->net_dev,

				    "invalid encapsulation type for RX_IP_INNER_CHKSUM_ERR: event="

				    EFX_QWORD_FMT "\n",

				    EFX_QWORD_VAL(*event));

		else if (unlikely(rx_l3_class != ESE_DZ_L3_CLASS_IP4 &&

				  rx_l3_class != ESE_DZ_L3_CLASS_IP4_FRAG &&

				  rx_l3_class != ESE_DZ_L3_CLASS_IP6 &&

				  rx_l3_class != ESE_DZ_L3_CLASS_IP6_FRAG))

			netdev_WARN(efx->net_dev,

				    "invalid class for RX_IP_INNER_CHKSUM_ERR: event="

				    EFX_QWORD_FMT "\n",

				    EFX_QWORD_VAL(*event));

		if (!efx->loopback_selftest)

			channel->n_rx_inner_ip_hdr_chksum_err += n_packets;

		return 0;

	}

	if (EFX_QWORD_FIELD(*event, ESF_EZ_RX_TCP_UDP_INNER_CHKSUM_ERR)) {

		if (unlikely(!rx_encap_hdr))

			netdev_WARN(efx->net_dev,

				    "invalid encapsulation type for RX_TCP_UDP_INNER_CHKSUM_ERR: event="

				    EFX_QWORD_FMT "\n",

				    EFX_QWORD_VAL(*event));

		else if (unlikely((rx_l3_class != ESE_DZ_L3_CLASS_IP4 &&

				   rx_l3_class != ESE_DZ_L3_CLASS_IP6) ||

				  (rx_l4_class != ESE_DZ_L4_CLASS_TCP &&

				   rx_l4_class != ESE_DZ_L4_CLASS_UDP)))

			netdev_WARN(efx->net_dev,

				    "invalid class for RX_TCP_UDP_INNER_CHKSUM_ERR: event="

				    EFX_QWORD_FMT "\n",

				    EFX_QWORD_VAL(*event));

		if (!efx->loopback_selftest)

			channel->n_rx_inner_tcp_udp_chksum_err += n_packets;

		return 0;

	}



	WARN_ON(1); /* No error bits were recognised */

	return 0;

}



static int efx_ef10_handle_rx_event(struct efx_channel *channel,

				    const efx_qword_t *event)

{

	unsigned int rx_bytes, next_ptr_lbits, rx_queue_label, rx_l4_class;

	unsigned int rx_bytes, next_ptr_lbits, rx_queue_label;

	unsigned int rx_l3_class, rx_l4_class, rx_encap_hdr;

	unsigned int n_descs, n_packets, i;

	struct efx_nic *efx = channel->efx;

	struct efx_ef10_nic_data *nic_data = efx->nic_data;

	struct efx_rx_queue *rx_queue;

	efx_qword_t errors;

	bool rx_cont;

	u16 flags = 0;
@@ -3171,8 +3281,14 @@ static int efx_ef10_handle_rx_event(struct efx_channel *channel, 
	rx_bytes = EFX_QWORD_FIELD(*event, ESF_DZ_RX_BYTES);

	next_ptr_lbits = EFX_QWORD_FIELD(*event, ESF_DZ_RX_DSC_PTR_LBITS);

	rx_queue_label = EFX_QWORD_FIELD(*event, ESF_DZ_RX_QLABEL);

	rx_l3_class = EFX_QWORD_FIELD(*event, ESF_DZ_RX_L3_CLASS);

	rx_l4_class = EFX_QWORD_FIELD(*event, ESF_DZ_RX_L4_CLASS);

	rx_cont = EFX_QWORD_FIELD(*event, ESF_DZ_RX_CONT);

	rx_encap_hdr =

		nic_data->datapath_caps &

			(1 << MC_CMD_GET_CAPABILITIES_OUT_VXLAN_NVGRE_LBN) ?

		EFX_QWORD_FIELD(*event, ESF_EZ_RX_ENCAP_HDR) :

		ESE_EZ_ENCAP_HDR_NONE;



	if (EFX_QWORD_FIELD(*event, ESF_DZ_RX_DROP_EVENT))

		netdev_WARN(efx->net_dev, "saw RX_DROP_EVENT: event="
@@ -3232,17 +3348,37 @@ static int efx_ef10_handle_rx_event(struct efx_channel *channel, 
		n_packets = 1;

	}



	if (unlikely(EFX_QWORD_FIELD(*event, ESF_DZ_RX_ECRC_ERR)))

		flags |= EFX_RX_PKT_DISCARD;



	if (unlikely(EFX_QWORD_FIELD(*event, ESF_DZ_RX_IPCKSUM_ERR))) {

		channel->n_rx_ip_hdr_chksum_err += n_packets;

	} else if (unlikely(EFX_QWORD_FIELD(*event,

					    ESF_DZ_RX_TCPUDP_CKSUM_ERR))) {

		channel->n_rx_tcp_udp_chksum_err += n_packets;

	} else if (rx_l4_class == ESE_DZ_L4_CLASS_TCP ||

		   rx_l4_class == ESE_DZ_L4_CLASS_UDP) {

	EFX_POPULATE_QWORD_5(errors, ESF_DZ_RX_ECRC_ERR, 1,

				     ESF_DZ_RX_IPCKSUM_ERR, 1,

				     ESF_DZ_RX_TCPUDP_CKSUM_ERR, 1,

				     ESF_EZ_RX_IP_INNER_CHKSUM_ERR, 1,

				     ESF_EZ_RX_TCP_UDP_INNER_CHKSUM_ERR, 1);

	EFX_AND_QWORD(errors, *event, errors);

	if (unlikely(!EFX_QWORD_IS_ZERO(errors))) {

		flags |= efx_ef10_handle_rx_event_errors(channel, n_packets,

							 rx_l3_class, rx_l4_class,

							 rx_encap_hdr, event);

	} else {

		bool tcpudp = rx_l4_class == ESE_DZ_L4_CLASS_TCP ||

			      rx_l4_class == ESE_DZ_L4_CLASS_UDP;



		switch (rx_encap_hdr) {

		case ESE_EZ_ENCAP_HDR_VXLAN: /* VxLAN or GENEVE */

			flags |= EFX_RX_PKT_CSUMMED; /* outer UDP csum */

			if (tcpudp)

				flags |= EFX_RX_PKT_CSUM_LEVEL; /* inner L4 */

			break;

		case ESE_EZ_ENCAP_HDR_GRE:

		case ESE_EZ_ENCAP_HDR_NONE:

			if (tcpudp)

				flags |= EFX_RX_PKT_CSUMMED;

			break;

		default:

			netdev_WARN(efx->net_dev,

				    "unknown encapsulation type: event="

				    EFX_QWORD_FMT "\n",

				    EFX_QWORD_VAL(*event));

		}

	}



	if (rx_l4_class == ESE_DZ_L4_CLASS_TCP)
@@ -5950,6 +6086,271 @@ static int efx_ef10_vlan_rx_kill_vid(struct efx_nic *efx, __be16 proto, u16 vid) 
	return efx_ef10_del_vlan(efx, vid);

}



/* We rely on the MCDI wiping out our TX rings if it made any changes to the

 * ports table, ensuring that any TSO descriptors that were made on a now-

 * removed tunnel port will be blown away and won't break things when we try

 * to transmit them using the new ports table.

 */

static int efx_ef10_set_udp_tnl_ports(struct efx_nic *efx, bool unloading)

{

	struct efx_ef10_nic_data *nic_data = efx->nic_data;

	MCDI_DECLARE_BUF(inbuf, MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_LENMAX);

	MCDI_DECLARE_BUF(outbuf, MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_OUT_LEN);

	bool will_reset = false;

	size_t num_entries = 0;

	size_t inlen, outlen;

	size_t i;

	int rc;

	efx_dword_t flags_and_num_entries;



	WARN_ON(!mutex_is_locked(&nic_data->udp_tunnels_lock));



	nic_data->udp_tunnels_dirty = false;



	if (!(nic_data->datapath_caps &

	    (1 << MC_CMD_GET_CAPABILITIES_OUT_VXLAN_NVGRE_LBN))) {

		netif_device_attach(efx->net_dev);

		return 0;

	}



	BUILD_BUG_ON(ARRAY_SIZE(nic_data->udp_tunnels) >

		     MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_ENTRIES_MAXNUM);



	for (i = 0; i < ARRAY_SIZE(nic_data->udp_tunnels); ++i) {

		if (nic_data->udp_tunnels[i].count &&

		    nic_data->udp_tunnels[i].port) {

			efx_dword_t entry;



			EFX_POPULATE_DWORD_2(entry,

				TUNNEL_ENCAP_UDP_PORT_ENTRY_UDP_PORT,

					ntohs(nic_data->udp_tunnels[i].port),

				TUNNEL_ENCAP_UDP_PORT_ENTRY_PROTOCOL,

					nic_data->udp_tunnels[i].type);

			*_MCDI_ARRAY_DWORD(inbuf,

				SET_TUNNEL_ENCAP_UDP_PORTS_IN_ENTRIES,

				num_entries++) = entry;

		}

	}



	BUILD_BUG_ON((MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_NUM_ENTRIES_OFST -

		      MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_FLAGS_OFST) * 8 !=

		     EFX_WORD_1_LBN);

	BUILD_BUG_ON(MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_NUM_ENTRIES_LEN * 8 !=

		     EFX_WORD_1_WIDTH);

	EFX_POPULATE_DWORD_2(flags_and_num_entries,

			     MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_UNLOADING,

				!!unloading,

			     EFX_WORD_1, num_entries);

	*_MCDI_DWORD(inbuf, SET_TUNNEL_ENCAP_UDP_PORTS_IN_FLAGS) =

		flags_and_num_entries;



	inlen = MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_LEN(num_entries);



	rc = efx_mcdi_rpc_quiet(efx, MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS,

				inbuf, inlen, outbuf, sizeof(outbuf), &outlen);

	if (rc == -EIO) {

		/* Most likely the MC rebooted due to another function also

		 * setting its tunnel port list. Mark the tunnel port list as

		 * dirty, so it will be pushed upon coming up from the reboot.

		 */

		nic_data->udp_tunnels_dirty = true;

		return 0;

	}



	if (rc) {

		/* expected not available on unprivileged functions */

		if (rc != -EPERM)

			netif_warn(efx, drv, efx->net_dev,

				   "Unable to set UDP tunnel ports; rc=%d.\n", rc);

	} else if (MCDI_DWORD(outbuf, SET_TUNNEL_ENCAP_UDP_PORTS_OUT_FLAGS) &

		   (1 << MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_OUT_RESETTING_LBN)) {

		netif_info(efx, drv, efx->net_dev,

			   "Rebooting MC due to UDP tunnel port list change\n");

		will_reset = true;

		if (unloading)

			/* Delay for the MC reset to complete. This will make

			 * unloading other functions a bit smoother. This is a

			 * race, but the other unload will work whichever way

			 * it goes, this just avoids an unnecessary error

			 * message.

			 */

			msleep(100);

	}

	if (!will_reset && !unloading) {

		/* The caller will have detached, relying on the MC reset to

		 * trigger a re-attach.  Since there won't be an MC reset, we

		 * have to do the attach ourselves.

		 */

		netif_device_attach(efx->net_dev);

	}



	return rc;

}



static int efx_ef10_udp_tnl_push_ports(struct efx_nic *efx)

{

	struct efx_ef10_nic_data *nic_data = efx->nic_data;

	int rc = 0;



	mutex_lock(&nic_data->udp_tunnels_lock);

	if (nic_data->udp_tunnels_dirty) {

		/* Make sure all TX are stopped while we modify the table, else

		 * we might race against an efx_features_check().

		 */

		efx_device_detach_sync(efx);

		rc = efx_ef10_set_udp_tnl_ports(efx, false);

	}

	mutex_unlock(&nic_data->udp_tunnels_lock);

	return rc;

}



static struct efx_udp_tunnel *__efx_ef10_udp_tnl_lookup_port(struct efx_nic *efx,

							     __be16 port)

{

	struct efx_ef10_nic_data *nic_data = efx->nic_data;

	size_t i;



	for (i = 0; i < ARRAY_SIZE(nic_data->udp_tunnels); ++i) {

		if (!nic_data->udp_tunnels[i].count)

			continue;

		if (nic_data->udp_tunnels[i].port == port)

			return &nic_data->udp_tunnels[i];

	}

	return NULL;

}



static int efx_ef10_udp_tnl_add_port(struct efx_nic *efx,

				     struct efx_udp_tunnel tnl)

{

	struct efx_ef10_nic_data *nic_data = efx->nic_data;

	struct efx_udp_tunnel *match;

	char typebuf[8];

	size_t i;

	int rc;



	if (!(nic_data->datapath_caps &

	      (1 << MC_CMD_GET_CAPABILITIES_OUT_VXLAN_NVGRE_LBN)))

		return 0;



	efx_get_udp_tunnel_type_name(tnl.type, typebuf, sizeof(typebuf));

	netif_dbg(efx, drv, efx->net_dev, "Adding UDP tunnel (%s) port %d\n",

		  typebuf, ntohs(tnl.port));



	mutex_lock(&nic_data->udp_tunnels_lock);

	/* Make sure all TX are stopped while we add to the table, else we

	 * might race against an efx_features_check().

	 */

	efx_device_detach_sync(efx);



	match = __efx_ef10_udp_tnl_lookup_port(efx, tnl.port);

	if (match != NULL) {

		if (match->type == tnl.type) {

			netif_dbg(efx, drv, efx->net_dev,

				  "Referencing existing tunnel entry\n");

			match->count++;

			/* No need to cause an MCDI update */

			rc = 0;

			goto unlock_out;

		}

		efx_get_udp_tunnel_type_name(match->type,

					     typebuf, sizeof(typebuf));

		netif_dbg(efx, drv, efx->net_dev,

			  "UDP port %d is already in use by %s\n",

			  ntohs(tnl.port), typebuf);

		rc = -EEXIST;

		goto unlock_out;

	}



	for (i = 0; i < ARRAY_SIZE(nic_data->udp_tunnels); ++i)

		if (!nic_data->udp_tunnels[i].count) {

			nic_data->udp_tunnels[i] = tnl;

			nic_data->udp_tunnels[i].count = 1;

			rc = efx_ef10_set_udp_tnl_ports(efx, false);

			goto unlock_out;

		}



	netif_dbg(efx, drv, efx->net_dev,

		  "Unable to add UDP tunnel (%s) port %d; insufficient resources.\n",

		  typebuf, ntohs(tnl.port));



	rc = -ENOMEM;



unlock_out:

	mutex_unlock(&nic_data->udp_tunnels_lock);

	return rc;

}



/* Called under the TX lock with the TX queue running, hence no-one can be

 * in the middle of updating the UDP tunnels table.  However, they could

 * have tried and failed the MCDI, in which case they'll have set the dirty

 * flag before dropping their locks.

 */

static bool efx_ef10_udp_tnl_has_port(struct efx_nic *efx, __be16 port)

{

	struct efx_ef10_nic_data *nic_data = efx->nic_data;



	if (!(nic_data->datapath_caps &

	      (1 << MC_CMD_GET_CAPABILITIES_OUT_VXLAN_NVGRE_LBN)))

		return false;



	if (nic_data->udp_tunnels_dirty)

		/* SW table may not match HW state, so just assume we can't

		 * use any UDP tunnel offloads.

		 */

		return false;



	return __efx_ef10_udp_tnl_lookup_port(efx, port) != NULL;

}



static int efx_ef10_udp_tnl_del_port(struct efx_nic *efx,

				     struct efx_udp_tunnel tnl)

{

	struct efx_ef10_nic_data *nic_data = efx->nic_data;

	struct efx_udp_tunnel *match;

	char typebuf[8];

	int rc;



	if (!(nic_data->datapath_caps &

	      (1 << MC_CMD_GET_CAPABILITIES_OUT_VXLAN_NVGRE_LBN)))

		return 0;



	efx_get_udp_tunnel_type_name(tnl.type, typebuf, sizeof(typebuf));

	netif_dbg(efx, drv, efx->net_dev, "Removing UDP tunnel (%s) port %d\n",

		  typebuf, ntohs(tnl.port));



	mutex_lock(&nic_data->udp_tunnels_lock);

	/* Make sure all TX are stopped while we remove from the table, else we

	 * might race against an efx_features_check().

	 */

	efx_device_detach_sync(efx);



	match = __efx_ef10_udp_tnl_lookup_port(efx, tnl.port);

	if (match != NULL) {

		if (match->type == tnl.type) {

			if (--match->count) {

				/* Port is still in use, so nothing to do */

				netif_dbg(efx, drv, efx->net_dev,

					  "UDP tunnel port %d remains active\n",

					  ntohs(tnl.port));

				rc = 0;

				goto out_unlock;

			}

			rc = efx_ef10_set_udp_tnl_ports(efx, false);

			goto out_unlock;

		}

		efx_get_udp_tunnel_type_name(match->type,

					     typebuf, sizeof(typebuf));

		netif_warn(efx, drv, efx->net_dev,

			   "UDP port %d is actually in use by %s, not removing\n",

			   ntohs(tnl.port), typebuf);

	}

	rc = -ENOENT;



out_unlock:

	mutex_unlock(&nic_data->udp_tunnels_lock);

	return rc;

}



#define EF10_OFFLOAD_FEATURES		\

	(NETIF_F_IP_CSUM |		\

	 NETIF_F_HW_VLAN_CTAG_FILTER |	\
@@ -6153,6 +6554,10 @@ const struct efx_nic_type efx_hunt_a0_nic_type = { 
	.ptp_set_ts_config = efx_ef10_ptp_set_ts_config,

	.vlan_rx_add_vid = efx_ef10_vlan_rx_add_vid,

	.vlan_rx_kill_vid = efx_ef10_vlan_rx_kill_vid,

	.udp_tnl_push_ports = efx_ef10_udp_tnl_push_ports,

	.udp_tnl_add_port = efx_ef10_udp_tnl_add_port,

	.udp_tnl_has_port = efx_ef10_udp_tnl_has_port,

	.udp_tnl_del_port = efx_ef10_udp_tnl_del_port,

#ifdef CONFIG_SFC_SRIOV

	.sriov_configure = efx_ef10_sriov_configure,

	.sriov_init = efx_ef10_sriov_init,

drivers/net/ethernet/sfc/efx.c

+136 −35
Original line number Diff line number Diff line
@@ -23,12 +23,15 @@ 
#include <linux/aer.h>

#include <linux/interrupt.h>

#include "net_driver.h"

#include <net/gre.h>

#include <net/udp_tunnel.h>

#include "efx.h"

#include "nic.h"

#include "selftest.h"

#include "sriov.h"



#include "mcdi.h"

#include "mcdi_pcol.h"

#include "workarounds.h"



/**************************************************************************
@@ -88,6 +91,21 @@ const char *const efx_reset_type_names[] = { 
	[RESET_TYPE_MCDI_TIMEOUT]	= "MCDI_TIMEOUT (FLR)",

};



/* UDP tunnel type names */

static const char *const efx_udp_tunnel_type_names[] = {

	[TUNNEL_ENCAP_UDP_PORT_ENTRY_VXLAN] = "vxlan",

	[TUNNEL_ENCAP_UDP_PORT_ENTRY_GENEVE] = "geneve",

};



void efx_get_udp_tunnel_type_name(u16 type, char *buf, size_t buflen)

{

	if (type < ARRAY_SIZE(efx_udp_tunnel_type_names) &&

	    efx_udp_tunnel_type_names[type] != NULL)

		snprintf(buf, buflen, "%s", efx_udp_tunnel_type_names[type]);

	else

		snprintf(buf, buflen, "type %d", type);

}



/* Reset workqueue. If any NIC has a hardware failure then a reset will be

 * queued onto this work queue. This is not a per-nic work queue, because

 * efx_reset_work() acquires the rtnl lock, so resets are naturally serialised.
@@ -2336,6 +2354,52 @@ static int efx_vlan_rx_kill_vid(struct net_device *net_dev, __be16 proto, u16 vi 
		return -EOPNOTSUPP;

}



static int efx_udp_tunnel_type_map(enum udp_parsable_tunnel_type in)

{

	switch (in) {

	case UDP_TUNNEL_TYPE_VXLAN:

		return TUNNEL_ENCAP_UDP_PORT_ENTRY_VXLAN;

	case UDP_TUNNEL_TYPE_GENEVE:

		return TUNNEL_ENCAP_UDP_PORT_ENTRY_GENEVE;

	default:

		return -1;

	}

}



static void efx_udp_tunnel_add(struct net_device *dev, struct udp_tunnel_info *ti)

{

	struct efx_nic *efx = netdev_priv(dev);

	struct efx_udp_tunnel tnl;

	int efx_tunnel_type;



	efx_tunnel_type = efx_udp_tunnel_type_map(ti->type);

	if (efx_tunnel_type < 0)

		return;



	tnl.type = (u16)efx_tunnel_type;

	tnl.port = ti->port;



	if (efx->type->udp_tnl_add_port)

		(void)efx->type->udp_tnl_add_port(efx, tnl);

}



static void efx_udp_tunnel_del(struct net_device *dev, struct udp_tunnel_info *ti)

{

	struct efx_nic *efx = netdev_priv(dev);

	struct efx_udp_tunnel tnl;

	int efx_tunnel_type;



	efx_tunnel_type = efx_udp_tunnel_type_map(ti->type);

	if (efx_tunnel_type < 0)

		return;



	tnl.type = (u16)efx_tunnel_type;

	tnl.port = ti->port;



	if (efx->type->udp_tnl_add_port)

		(void)efx->type->udp_tnl_del_port(efx, tnl);

}



static const struct net_device_ops efx_netdev_ops = {

	.ndo_open		= efx_net_open,

	.ndo_stop		= efx_net_stop,
@@ -2366,6 +2430,8 @@ static const struct net_device_ops efx_netdev_ops = { 
#ifdef CONFIG_RFS_ACCEL

	.ndo_rx_flow_steer	= efx_filter_rfs,

#endif

	.ndo_udp_tunnel_add	= efx_udp_tunnel_add,

	.ndo_udp_tunnel_del	= efx_udp_tunnel_del,

};



static void efx_update_name(struct efx_nic *efx)
@@ -2605,6 +2671,9 @@ int efx_reset_up(struct efx_nic *efx, enum reset_type method, bool ok) 


	efx_start_all(efx);



	if (efx->type->udp_tnl_push_ports)

		efx->type->udp_tnl_push_ports(efx);



	return 0;



fail:
@@ -3136,6 +3205,51 @@ static int efx_pci_probe_main(struct efx_nic *efx) 
	return rc;

}



static int efx_pci_probe_post_io(struct efx_nic *efx)

{

	struct net_device *net_dev = efx->net_dev;

	int rc = efx_pci_probe_main(efx);



	if (rc)

		return rc;



	if (efx->type->sriov_init) {

		rc = efx->type->sriov_init(efx);

		if (rc)

			netif_err(efx, probe, efx->net_dev,

				  "SR-IOV can't be enabled rc %d\n", rc);

	}



	/* Determine netdevice features */

	net_dev->features |= (efx->type->offload_features | NETIF_F_SG |

			      NETIF_F_TSO | NETIF_F_RXCSUM);

	if (efx->type->offload_features & (NETIF_F_IPV6_CSUM | NETIF_F_HW_CSUM))

		net_dev->features |= NETIF_F_TSO6;

	/* Check whether device supports TSO */

	if (!efx->type->tso_versions || !efx->type->tso_versions(efx))

		net_dev->features &= ~NETIF_F_ALL_TSO;

	/* Mask for features that also apply to VLAN devices */

	net_dev->vlan_features |= (NETIF_F_HW_CSUM | NETIF_F_SG |

				   NETIF_F_HIGHDMA | NETIF_F_ALL_TSO |

				   NETIF_F_RXCSUM);



	net_dev->hw_features = net_dev->features & ~efx->fixed_features;



	/* Disable VLAN filtering by default.  It may be enforced if

	 * the feature is fixed (i.e. VLAN filters are required to

	 * receive VLAN tagged packets due to vPort restrictions).

	 */

	net_dev->features &= ~NETIF_F_HW_VLAN_CTAG_FILTER;

	net_dev->features |= efx->fixed_features;



	rc = efx_register_netdev(efx);

	if (!rc)

		return 0;



	efx_pci_remove_main(efx);

	return rc;

}



/* NIC initialisation

 *

 * This is called at module load (or hotplug insertion,
@@ -3178,41 +3292,27 @@ static int efx_pci_probe(struct pci_dev *pci_dev, 
	if (rc)

		goto fail2;



	rc = efx_pci_probe_main(efx);

	if (rc)

		goto fail3;



	net_dev->features |= (efx->type->offload_features | NETIF_F_SG |

			      NETIF_F_TSO | NETIF_F_RXCSUM);

	if (efx->type->offload_features & (NETIF_F_IPV6_CSUM | NETIF_F_HW_CSUM))

		net_dev->features |= NETIF_F_TSO6;

	/* Check whether device supports TSO */

	if (!efx->type->tso_versions || !efx->type->tso_versions(efx))

		net_dev->features &= ~NETIF_F_ALL_TSO;

	/* Mask for features that also apply to VLAN devices */

	net_dev->vlan_features |= (NETIF_F_HW_CSUM | NETIF_F_SG |

				   NETIF_F_HIGHDMA | NETIF_F_ALL_TSO |

				   NETIF_F_RXCSUM);



	net_dev->hw_features = net_dev->features & ~efx->fixed_features;



	/* Disable VLAN filtering by default.  It may be enforced if

	 * the feature is fixed (i.e. VLAN filters are required to

	 * receive VLAN tagged packets due to vPort restrictions).

	rc = efx_pci_probe_post_io(efx);

	if (rc) {

		/* On failure, retry once immediately.

		 * If we aborted probe due to a scheduled reset, dismiss it.

		 */

	net_dev->features &= ~NETIF_F_HW_VLAN_CTAG_FILTER;

	net_dev->features |= efx->fixed_features;



	rc = efx_register_netdev(efx);

	if (rc)

		goto fail4;

		efx->reset_pending = 0;

		rc = efx_pci_probe_post_io(efx);

		if (rc) {

			/* On another failure, retry once more

			 * after a 50-305ms delay.

			 */

			unsigned char r;



	if (efx->type->sriov_init) {

		rc = efx->type->sriov_init(efx);

		if (rc)

			netif_err(efx, probe, efx->net_dev,

				  "SR-IOV can't be enabled rc %d\n", rc);

			get_random_bytes(&r, 1);

			msleep((unsigned int)r + 50);

			efx->reset_pending = 0;

			rc = efx_pci_probe_post_io(efx);

		}

	}

	if (rc)

		goto fail3;



	netif_dbg(efx, probe, efx->net_dev, "initialisation successful\n");
@@ -3230,10 +3330,11 @@ static int efx_pci_probe(struct pci_dev *pci_dev, 
			     "PCIE error reporting unavailable (%d).\n",

			     rc);



	if (efx->type->udp_tnl_push_ports)

		efx->type->udp_tnl_push_ports(efx);



	return 0;



 fail4:

	efx_pci_remove_main(efx);

 fail3:

	efx_fini_io(efx);

 fail2:

drivers/net/ethernet/sfc/ethtool.c

+5 −0
Original line number Diff line number Diff line
@@ -77,6 +77,11 @@ static const struct efx_sw_stat_desc efx_sw_stat_desc[] = { 
	EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_tobe_disc),

	EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_ip_hdr_chksum_err),

	EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_tcp_udp_chksum_err),

	EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_inner_ip_hdr_chksum_err),

	EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_inner_tcp_udp_chksum_err),

	EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_outer_ip_hdr_chksum_err),

	EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_outer_tcp_udp_chksum_err),

	EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_eth_crc_err),

	EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_mcast_mismatch),

	EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_frm_trunc),

	EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_merge_events),

drivers/net/ethernet/sfc/mcdi.c

+12 −3
Original line number Diff line number Diff line
@@ -128,7 +128,7 @@ int efx_mcdi_init(struct efx_nic *efx) 
	return rc;

}



void efx_mcdi_fini(struct efx_nic *efx)

void efx_mcdi_detach(struct efx_nic *efx)

{

	if (!efx->mcdi)

		return;
@@ -137,6 +137,12 @@ void efx_mcdi_fini(struct efx_nic *efx) 


	/* Relinquish the device (back to the BMC, if this is a LOM) */

	efx_mcdi_drv_attach(efx, false, NULL);

}



void efx_mcdi_fini(struct efx_nic *efx)

{

	if (!efx->mcdi)

		return;



#ifdef CONFIG_SFC_MCDI_LOGGING

	free_page((unsigned long)efx->mcdi->iface.logging_buffer);
@@ -716,8 +722,11 @@ static int _efx_mcdi_rpc_finish(struct efx_nic *efx, unsigned int cmd, 
		if (cmd == MC_CMD_REBOOT && rc == -EIO) {

			/* Don't reset if MC_CMD_REBOOT returns EIO */

		} else if (rc == -EIO || rc == -EINTR) {

			netif_err(efx, hw, efx->net_dev, "MC fatal error %d\n",

				  -rc);

			netif_err(efx, hw, efx->net_dev, "MC reboot detected\n");

			netif_dbg(efx, hw, efx->net_dev, "MC rebooted during command %d rc %d\n",

				  cmd, -rc);

			if (efx->type->mcdi_reboot_detected)

				efx->type->mcdi_reboot_detected(efx);

			efx_schedule_reset(efx, RESET_TYPE_MC_FAILURE);

		} else if (proxy_handle && (rc == -EPROTO) &&

			   efx_mcdi_get_proxy_handle(efx, hdr_len, data_len,