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

Merge branch '100GbE' of git://git.kernel.org/pub/scm/linux/kernel/git/jkirsher/next-queue 



Jeff Kirsher says:

====================
100GbE Intel Wired LAN Driver Updates 2017-10-03

This series contains updates to fm10k only.

Jake provides majority of the changes in this series, starting with using
fm10k_prepare_for_reset() if we lose PCIe link.  Before we would detach
the device and close the netdev, which left a lot of items still active,
such as the Tx/Rx resources.  This could cause problems where register
reads would return potentially invalid values and would result in unknown
driver behavior, so call fm10k_prepare_for_reset() much like we do for
suspend/resume cycles.  This will attempt to shutdown as much as possible
to prevent possible issues.  Then replaced the PCI specific legacy power
management hooks with the new generic power management hooks for both
suspend and hibernate.  Introduced a workqueue item which monitors a
queue of MAC and VLAN requests since a large number of MAC address or
VLAN updates at once can overload the mailbox with too many messages at
once.  Fixed a cppcheck warning by properly declaring the min_rate and
max_rate variables in the declaration and definition for .ndo_set_vf_bw,
rather than using "unused" for the minimum rates.

Joe Perches fixes the backward logic when using net_ratelimit().
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 6c557001 3e256ac5

drivers/net/ethernet/intel/fm10k/fm10k.h

+48 −12
Original line number Diff line number Diff line
@@ -248,6 +248,29 @@ struct fm10k_udp_port { 
	__be16			port;

};



enum fm10k_macvlan_request_type {

	FM10K_UC_MAC_REQUEST,

	FM10K_MC_MAC_REQUEST,

	FM10K_VLAN_REQUEST

};



struct fm10k_macvlan_request {

	enum fm10k_macvlan_request_type type;

	struct list_head list;

	union {

		struct fm10k_mac_request {

			u8 addr[ETH_ALEN];

			u16 glort;

			u16 vid;

		} mac;

		struct fm10k_vlan_request {

			u32 vid;

			u8 vsi;

		} vlan;

	};

	bool set;

};



/* one work queue for entire driver */

extern struct workqueue_struct *fm10k_workqueue;
@@ -270,11 +293,15 @@ enum fm10k_flags_t { 


enum fm10k_state_t {

	__FM10K_RESETTING,

	__FM10K_RESET_DETACHED,

	__FM10K_RESET_SUSPENDED,

	__FM10K_DOWN,

	__FM10K_SERVICE_SCHED,

	__FM10K_SERVICE_REQUEST,

	__FM10K_SERVICE_DISABLE,

	__FM10K_MBX_LOCK,

	__FM10K_MACVLAN_SCHED,

	__FM10K_MACVLAN_REQUEST,

	__FM10K_MACVLAN_DISABLE,

	__FM10K_LINK_DOWN,

	__FM10K_UPDATING_STATS,

	/* This value must be last and determines the BITMAP size */
@@ -344,6 +371,8 @@ struct fm10k_intfc { 


	struct fm10k_hw_stats stats;

	struct fm10k_hw hw;

	/* Mailbox lock */

	spinlock_t mbx_lock;

	u32 __iomem *uc_addr;

	u32 __iomem *sw_addr;

	u16 msg_enable;
@@ -365,6 +394,12 @@ struct fm10k_intfc { 
	struct list_head vxlan_port;

	struct list_head geneve_port;



	/* MAC/VLAN update queue */

	struct list_head macvlan_requests;

	struct delayed_work macvlan_task;

	/* MAC/VLAN update queue lock */

	spinlock_t macvlan_lock;



#ifdef CONFIG_DEBUG_FS

	struct dentry *dbg_intfc;

#endif /* CONFIG_DEBUG_FS */
@@ -384,23 +419,17 @@ struct fm10k_intfc { 


static inline void fm10k_mbx_lock(struct fm10k_intfc *interface)

{

	/* busy loop if we cannot obtain the lock as some calls

	 * such as ndo_set_rx_mode may be made in atomic context

	 */

	while (test_and_set_bit(__FM10K_MBX_LOCK, interface->state))

		udelay(20);

	spin_lock(&interface->mbx_lock);

}



static inline void fm10k_mbx_unlock(struct fm10k_intfc *interface)

{

	/* flush memory to make sure state is correct */

	smp_mb__before_atomic();

	clear_bit(__FM10K_MBX_LOCK, interface->state);

	spin_unlock(&interface->mbx_lock);

}



static inline int fm10k_mbx_trylock(struct fm10k_intfc *interface)

{

	return !test_and_set_bit(__FM10K_MBX_LOCK, interface->state);

	return spin_trylock(&interface->mbx_lock);

}



/* fm10k_test_staterr - test bits in Rx descriptor status and error fields */
@@ -490,6 +519,7 @@ void fm10k_up(struct fm10k_intfc *interface); 
void fm10k_down(struct fm10k_intfc *interface);

void fm10k_update_stats(struct fm10k_intfc *interface);

void fm10k_service_event_schedule(struct fm10k_intfc *interface);

void fm10k_macvlan_schedule(struct fm10k_intfc *interface);

void fm10k_update_rx_drop_en(struct fm10k_intfc *interface);

#ifdef CONFIG_NET_POLL_CONTROLLER

void fm10k_netpoll(struct net_device *netdev);
@@ -510,6 +540,12 @@ void fm10k_reset_rx_state(struct fm10k_intfc *); 
int fm10k_setup_tc(struct net_device *dev, u8 tc);

int fm10k_open(struct net_device *netdev);

int fm10k_close(struct net_device *netdev);

int fm10k_queue_vlan_request(struct fm10k_intfc *interface, u32 vid,

			     u8 vsi, bool set);

int fm10k_queue_mac_request(struct fm10k_intfc *interface, u16 glort,

			    const unsigned char *addr, u16 vid, bool set);

void fm10k_clear_macvlan_queue(struct fm10k_intfc *interface,

			       u16 glort, bool vlans);



/* Ethtool */

void fm10k_set_ethtool_ops(struct net_device *dev);
@@ -526,8 +562,8 @@ s32 fm10k_iov_update_pvid(struct fm10k_intfc *interface, u16 glort, u16 pvid); 
int fm10k_ndo_set_vf_mac(struct net_device *netdev, int vf_idx, u8 *mac);

int fm10k_ndo_set_vf_vlan(struct net_device *netdev,

			  int vf_idx, u16 vid, u8 qos, __be16 vlan_proto);

int fm10k_ndo_set_vf_bw(struct net_device *netdev, int vf_idx, int rate,

			int unused);

int fm10k_ndo_set_vf_bw(struct net_device *netdev, int vf_idx,

			int __always_unused min_rate, int max_rate);

int fm10k_ndo_get_vf_config(struct net_device *netdev,

			    int vf_idx, struct ifla_vf_info *ivi);

drivers/net/ethernet/intel/fm10k/fm10k_iov.c

+135 −6
Original line number Diff line number Diff line
@@ -35,10 +35,133 @@ static s32 fm10k_iov_msg_error(struct fm10k_hw *hw, u32 **results, 
	return fm10k_tlv_msg_error(hw, results, mbx);

}



/**

 *  fm10k_iov_msg_queue_mac_vlan - Message handler for MAC/VLAN request from VF

 *  @hw: Pointer to hardware structure

 *  @results: Pointer array to message, results[0] is pointer to message

 *  @mbx: Pointer to mailbox information structure

 *

 *  This function is a custom handler for MAC/VLAN requests from the VF. The

 *  assumption is that it is acceptable to directly hand off the message from

 *  the VF to the PF's switch manager. However, we use a MAC/VLAN message

 *  queue to avoid overloading the mailbox when a large number of requests

 *  come in.

 **/

static s32 fm10k_iov_msg_queue_mac_vlan(struct fm10k_hw *hw, u32 **results,

					struct fm10k_mbx_info *mbx)

{

	struct fm10k_vf_info *vf_info = (struct fm10k_vf_info *)mbx;

	struct fm10k_intfc *interface = hw->back;

	u8 mac[ETH_ALEN];

	u32 *result;

	int err = 0;

	bool set;

	u16 vlan;

	u32 vid;



	/* we shouldn't be updating rules on a disabled interface */

	if (!FM10K_VF_FLAG_ENABLED(vf_info))

		err = FM10K_ERR_PARAM;



	if (!err && !!results[FM10K_MAC_VLAN_MSG_VLAN]) {

		result = results[FM10K_MAC_VLAN_MSG_VLAN];



		/* record VLAN id requested */

		err = fm10k_tlv_attr_get_u32(result, &vid);

		if (err)

			return err;



		set = !(vid & FM10K_VLAN_CLEAR);

		vid &= ~FM10K_VLAN_CLEAR;



		/* if the length field has been set, this is a multi-bit

		 * update request. For multi-bit requests, simply disallow

		 * them when the pf_vid has been set. In this case, the PF

		 * should have already cleared the VLAN_TABLE, and if we

		 * allowed them, it could allow a rogue VF to receive traffic

		 * on a VLAN it was not assigned. In the single-bit case, we

		 * need to modify requests for VLAN 0 to use the default PF or

		 * SW vid when assigned.

		 */



		if (vid >> 16) {

			/* prevent multi-bit requests when PF has

			 * administratively set the VLAN for this VF

			 */

			if (vf_info->pf_vid)

				return FM10K_ERR_PARAM;

		} else {

			err = fm10k_iov_select_vid(vf_info, (u16)vid);

			if (err < 0)

				return err;



			vid = err;

		}



		/* update VSI info for VF in regards to VLAN table */

		err = hw->mac.ops.update_vlan(hw, vid, vf_info->vsi, set);

	}



	if (!err && !!results[FM10K_MAC_VLAN_MSG_MAC]) {

		result = results[FM10K_MAC_VLAN_MSG_MAC];



		/* record unicast MAC address requested */

		err = fm10k_tlv_attr_get_mac_vlan(result, mac, &vlan);

		if (err)

			return err;



		/* block attempts to set MAC for a locked device */

		if (is_valid_ether_addr(vf_info->mac) &&

		    !ether_addr_equal(mac, vf_info->mac))

			return FM10K_ERR_PARAM;



		set = !(vlan & FM10K_VLAN_CLEAR);

		vlan &= ~FM10K_VLAN_CLEAR;



		err = fm10k_iov_select_vid(vf_info, vlan);

		if (err < 0)

			return err;



		vlan = (u16)err;



		/* Add this request to the MAC/VLAN queue */

		err = fm10k_queue_mac_request(interface, vf_info->glort,

					      mac, vlan, set);

	}



	if (!err && !!results[FM10K_MAC_VLAN_MSG_MULTICAST]) {

		result = results[FM10K_MAC_VLAN_MSG_MULTICAST];



		/* record multicast MAC address requested */

		err = fm10k_tlv_attr_get_mac_vlan(result, mac, &vlan);

		if (err)

			return err;



		/* verify that the VF is allowed to request multicast */

		if (!(vf_info->vf_flags & FM10K_VF_FLAG_MULTI_ENABLED))

			return FM10K_ERR_PARAM;



		set = !(vlan & FM10K_VLAN_CLEAR);

		vlan &= ~FM10K_VLAN_CLEAR;



		err = fm10k_iov_select_vid(vf_info, vlan);

		if (err < 0)

			return err;



		vlan = (u16)err;



		/* Add this request to the MAC/VLAN queue */

		err = fm10k_queue_mac_request(interface, vf_info->glort,

					      mac, vlan, set);

	}



	return err;

}



static const struct fm10k_msg_data iov_mbx_data[] = {

	FM10K_TLV_MSG_TEST_HANDLER(fm10k_tlv_msg_test),

	FM10K_VF_MSG_MSIX_HANDLER(fm10k_iov_msg_msix_pf),

	FM10K_VF_MSG_MAC_VLAN_HANDLER(fm10k_iov_msg_mac_vlan_pf),

	FM10K_VF_MSG_MAC_VLAN_HANDLER(fm10k_iov_msg_queue_mac_vlan),

	FM10K_VF_MSG_LPORT_STATE_HANDLER(fm10k_iov_msg_lport_state_pf),

	FM10K_TLV_MSG_ERROR_HANDLER(fm10k_iov_msg_error),

};
@@ -126,8 +249,10 @@ process_mbx: 
		hw->mbx.ops.process(hw, &hw->mbx);



		/* verify port mapping is valid, if not reset port */

		if (vf_info->vf_flags && !fm10k_glort_valid_pf(hw, glort))

		if (vf_info->vf_flags && !fm10k_glort_valid_pf(hw, glort)) {

			hw->iov.ops.reset_lport(hw, vf_info);

			fm10k_clear_macvlan_queue(interface, glort, false);

		}



		/* reset VFs that have mailbox timed out */

		if (!mbx->timeout) {
@@ -190,6 +315,7 @@ void fm10k_iov_suspend(struct pci_dev *pdev) 


		hw->iov.ops.reset_resources(hw, vf_info);

		hw->iov.ops.reset_lport(hw, vf_info);

		fm10k_clear_macvlan_queue(interface, vf_info->glort, false);

	}

}
@@ -414,6 +540,8 @@ static inline void fm10k_reset_vf_info(struct fm10k_intfc *interface, 
	/* disable LPORT for this VF which clears switch rules */

	hw->iov.ops.reset_lport(hw, vf_info);



	fm10k_clear_macvlan_queue(interface, vf_info->glort, false);



	/* assign new MAC+VLAN for this VF */

	hw->iov.ops.assign_default_mac_vlan(hw, vf_info);
@@ -485,7 +613,7 @@ int fm10k_ndo_set_vf_vlan(struct net_device *netdev, int vf_idx, u16 vid, 
}



int fm10k_ndo_set_vf_bw(struct net_device *netdev, int vf_idx,

			int __always_unused unused, int rate)

			int __always_unused min_rate, int max_rate)

{

	struct fm10k_intfc *interface = netdev_priv(netdev);

	struct fm10k_iov_data *iov_data = interface->iov_data;
@@ -496,14 +624,15 @@ int fm10k_ndo_set_vf_bw(struct net_device *netdev, int vf_idx, 
		return -EINVAL;



	/* rate limit cannot be less than 10Mbs or greater than link speed */

	if (rate && ((rate < FM10K_VF_TC_MIN) || rate > FM10K_VF_TC_MAX))

	if (max_rate &&

	    (max_rate < FM10K_VF_TC_MIN || max_rate > FM10K_VF_TC_MAX))

		return -EINVAL;



	/* store values */

	iov_data->vf_info[vf_idx].rate = rate;

	iov_data->vf_info[vf_idx].rate = max_rate;



	/* update hardware configuration */

	hw->iov.ops.configure_tc(hw, vf_idx, rate);

	hw->iov.ops.configure_tc(hw, vf_idx, max_rate);



	return 0;

}

drivers/net/ethernet/intel/fm10k/fm10k_main.c

+3 −2
Original line number Diff line number Diff line
@@ -28,7 +28,7 @@ 


#include "fm10k.h"



#define DRV_VERSION	"0.21.7-k"

#define DRV_VERSION	"0.22.1-k"

#define DRV_SUMMARY	"Intel(R) Ethernet Switch Host Interface Driver"

const char fm10k_driver_version[] = DRV_VERSION;

char fm10k_driver_name[] = "fm10k";
@@ -806,9 +806,10 @@ static int fm10k_tso(struct fm10k_ring *tx_ring, 
	tx_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);



	return 1;



err_vxlan:

	tx_ring->netdev->features &= ~NETIF_F_GSO_UDP_TUNNEL;

	if (!net_ratelimit())

	if (net_ratelimit())

		netdev_err(tx_ring->netdev,

			   "TSO requested for unsupported tunnel, disabling offload\n");

	return -1;

drivers/net/ethernet/intel/fm10k/fm10k_netdev.c

+157 −42
Original line number Diff line number Diff line
@@ -758,11 +758,132 @@ static bool fm10k_host_mbx_ready(struct fm10k_intfc *interface) 
	return (hw->mac.type == fm10k_mac_vf || interface->host_ready);

}



/**

 * fm10k_queue_vlan_request - Queue a VLAN update request

 * @interface: the fm10k interface structure

 * @vid: the VLAN vid

 * @vsi: VSI index number

 * @set: whether to set or clear

 *

 * This function queues up a VLAN update. For VFs, this must be sent to the

 * managing PF over the mailbox. For PFs, we'll use the same handling so that

 * it's similar to the VF. This avoids storming the PF<->VF mailbox with too

 * many VLAN updates during reset.

 */

int fm10k_queue_vlan_request(struct fm10k_intfc *interface,

			     u32 vid, u8 vsi, bool set)

{

	struct fm10k_macvlan_request *request;

	unsigned long flags;



	/* This must be atomic since we may be called while the netdev

	 * addr_list_lock is held

	 */

	request = kzalloc(sizeof(*request), GFP_ATOMIC);

	if (!request)

		return -ENOMEM;



	request->type = FM10K_VLAN_REQUEST;

	request->vlan.vid = vid;

	request->vlan.vsi = vsi;

	request->set = set;



	spin_lock_irqsave(&interface->macvlan_lock, flags);

	list_add_tail(&request->list, &interface->macvlan_requests);

	spin_unlock_irqrestore(&interface->macvlan_lock, flags);



	fm10k_macvlan_schedule(interface);



	return 0;

}



/**

 * fm10k_queue_mac_request - Queue a MAC update request

 * @interface: the fm10k interface structure

 * @glort: the target glort for this update

 * @addr: the address to update

 * @vid: the vid to update

 * @sync: whether to add or remove

 *

 * This function queues up a MAC request for sending to the switch manager.

 * A separate thread monitors the queue and sends updates to the switch

 * manager. Return 0 on success, and negative error code on failure.

 **/

int fm10k_queue_mac_request(struct fm10k_intfc *interface, u16 glort,

			    const unsigned char *addr, u16 vid, bool set)

{

	struct fm10k_macvlan_request *request;

	unsigned long flags;



	/* This must be atomic since we may be called while the netdev

	 * addr_list_lock is held

	 */

	request = kzalloc(sizeof(*request), GFP_ATOMIC);

	if (!request)

		return -ENOMEM;



	if (is_multicast_ether_addr(addr))

		request->type = FM10K_MC_MAC_REQUEST;

	else

		request->type = FM10K_UC_MAC_REQUEST;



	ether_addr_copy(request->mac.addr, addr);

	request->mac.glort = glort;

	request->mac.vid = vid;

	request->set = set;



	spin_lock_irqsave(&interface->macvlan_lock, flags);

	list_add_tail(&request->list, &interface->macvlan_requests);

	spin_unlock_irqrestore(&interface->macvlan_lock, flags);



	fm10k_macvlan_schedule(interface);



	return 0;

}



/**

 * fm10k_clear_macvlan_queue - Cancel pending updates for a given glort

 * @interface: the fm10k interface structure

 * @glort: the target glort to clear

 * @vlans: true to clear VLAN messages, false to ignore them

 *

 * Cancel any outstanding MAC/VLAN requests for a given glort. This is

 * expected to be called when a logical port goes down.

 **/

void fm10k_clear_macvlan_queue(struct fm10k_intfc *interface,

			       u16 glort, bool vlans)



{

	struct fm10k_macvlan_request *r, *tmp;

	unsigned long flags;



	spin_lock_irqsave(&interface->macvlan_lock, flags);



	/* Free any outstanding MAC/VLAN requests for this interface */

	list_for_each_entry_safe(r, tmp, &interface->macvlan_requests, list) {

		switch (r->type) {

		case FM10K_MC_MAC_REQUEST:

		case FM10K_UC_MAC_REQUEST:

			/* Don't free requests for other interfaces */

			if (r->mac.glort != glort)

				break;

			/* fall through */

		case FM10K_VLAN_REQUEST:

			if (vlans) {

				list_del(&r->list);

				kfree(r);

			}

			break;

		}

	}



	spin_unlock_irqrestore(&interface->macvlan_lock, flags);

}



static int fm10k_uc_vlan_unsync(struct net_device *netdev,

				const unsigned char *uc_addr)

{

	struct fm10k_intfc *interface = netdev_priv(netdev);

	struct fm10k_hw *hw = &interface->hw;

	u16 glort = interface->glort;

	u16 vid = interface->vid;

	bool set = !!(vid / VLAN_N_VID);
@@ -771,10 +892,7 @@ static int fm10k_uc_vlan_unsync(struct net_device *netdev, 
	/* drop any leading bits on the VLAN ID */

	vid &= VLAN_N_VID - 1;



	if (fm10k_host_mbx_ready(interface))

		err = hw->mac.ops.update_uc_addr(hw, glort, uc_addr,

						 vid, set, 0);



	err = fm10k_queue_mac_request(interface, glort, uc_addr, vid, set);

	if (err)

		return err;
@@ -786,7 +904,6 @@ static int fm10k_mc_vlan_unsync(struct net_device *netdev, 
				const unsigned char *mc_addr)

{

	struct fm10k_intfc *interface = netdev_priv(netdev);

	struct fm10k_hw *hw = &interface->hw;

	u16 glort = interface->glort;

	u16 vid = interface->vid;

	bool set = !!(vid / VLAN_N_VID);
@@ -795,9 +912,7 @@ static int fm10k_mc_vlan_unsync(struct net_device *netdev, 
	/* drop any leading bits on the VLAN ID */

	vid &= VLAN_N_VID - 1;



	if (fm10k_host_mbx_ready(interface))

		err = hw->mac.ops.update_mc_addr(hw, glort, mc_addr, vid, set);



	err = fm10k_queue_mac_request(interface, glort, mc_addr, vid, set);

	if (err)

		return err;
@@ -855,18 +970,14 @@ static int fm10k_update_vid(struct net_device *netdev, u16 vid, bool set) 


	/* only need to update the VLAN if not in promiscuous mode */

	if (!(netdev->flags & IFF_PROMISC)) {

		err = hw->mac.ops.update_vlan(hw, vid, 0, set);

		err = fm10k_queue_vlan_request(interface, vid, 0, set);

		if (err)

			goto err_out;

	}



	/* update our base MAC address if host's mailbox is ready */

	if (fm10k_host_mbx_ready(interface))

		err = hw->mac.ops.update_uc_addr(hw, interface->glort,

						 hw->mac.addr, vid, set, 0);

	else

		err = -EHOSTDOWN;



	/* Update our base MAC address */

	err = fm10k_queue_mac_request(interface, interface->glort,

				      hw->mac.addr, vid, set);

	if (err)

		goto err_out;
@@ -910,7 +1021,6 @@ static u16 fm10k_find_next_vlan(struct fm10k_intfc *interface, u16 vid) 


static void fm10k_clear_unused_vlans(struct fm10k_intfc *interface)

{

	struct fm10k_hw *hw = &interface->hw;

	u32 vid, prev_vid;



	/* loop through and find any gaps in the table */
@@ -922,7 +1032,7 @@ static void fm10k_clear_unused_vlans(struct fm10k_intfc *interface) 


		/* send request to clear multiple bits at a time */

		prev_vid += (vid - prev_vid - 1) << FM10K_VLAN_LENGTH_SHIFT;

		hw->mac.ops.update_vlan(hw, prev_vid, 0, false);

		fm10k_queue_vlan_request(interface, prev_vid, 0, false);

	}

}
@@ -937,15 +1047,11 @@ static int __fm10k_uc_sync(struct net_device *dev, 
	if (!is_valid_ether_addr(addr))

		return -EADDRNOTAVAIL;



	/* update table with current entries if host's mailbox is ready */

	if (!fm10k_host_mbx_ready(interface))

		return -EHOSTDOWN;



	for (vid = hw->mac.default_vid ? fm10k_find_next_vlan(interface, 0) : 1;

	     vid < VLAN_N_VID;

	     vid = fm10k_find_next_vlan(interface, vid)) {

		err = hw->mac.ops.update_uc_addr(hw, glort, addr,

						 vid, sync, 0);

		err = fm10k_queue_mac_request(interface, glort,

					      addr, vid, sync);

		if (err)

			return err;

	}
@@ -1002,15 +1108,18 @@ static int __fm10k_mc_sync(struct net_device *dev, 
	struct fm10k_intfc *interface = netdev_priv(dev);

	struct fm10k_hw *hw = &interface->hw;

	u16 vid, glort = interface->glort;

	s32 err;



	/* update table with current entries if host's mailbox is ready */

	if (!fm10k_host_mbx_ready(interface))

		return 0;

	if (!is_multicast_ether_addr(addr))

		return -EADDRNOTAVAIL;



	for (vid = hw->mac.default_vid ? fm10k_find_next_vlan(interface, 0) : 1;

	     vid < VLAN_N_VID;

	     vid = fm10k_find_next_vlan(interface, vid)) {

		hw->mac.ops.update_mc_addr(hw, glort, addr, vid, sync);

		err = fm10k_queue_mac_request(interface, glort,

					      addr, vid, sync);

		if (err)

			return err;

	}



	return 0;
@@ -1050,7 +1159,8 @@ static void fm10k_set_rx_mode(struct net_device *dev) 
	if (interface->xcast_mode != xcast_mode) {

		/* update VLAN table */

		if (xcast_mode == FM10K_XCAST_MODE_PROMISC)

			hw->mac.ops.update_vlan(hw, FM10K_VLAN_ALL, 0, true);

			fm10k_queue_vlan_request(interface, FM10K_VLAN_ALL,

						 0, true);

		if (interface->xcast_mode == FM10K_XCAST_MODE_PROMISC)

			fm10k_clear_unused_vlans(interface);
@@ -1098,22 +1208,20 @@ void fm10k_restore_rx_state(struct fm10k_intfc *interface) 
					       interface->glort_count, true);



	/* update VLAN table */

	hw->mac.ops.update_vlan(hw, FM10K_VLAN_ALL, 0,

	fm10k_queue_vlan_request(interface, FM10K_VLAN_ALL, 0,

				 xcast_mode == FM10K_XCAST_MODE_PROMISC);



	/* Add filter for VLAN 0 */

	hw->mac.ops.update_vlan(hw, 0, 0, true);

	fm10k_queue_vlan_request(interface, 0, 0, true);



	/* update table with current entries */

	for (vid = hw->mac.default_vid ? fm10k_find_next_vlan(interface, 0) : 1;

	     vid < VLAN_N_VID;

	     vid = fm10k_find_next_vlan(interface, vid)) {

		hw->mac.ops.update_vlan(hw, vid, 0, true);

		fm10k_queue_vlan_request(interface, vid, 0, true);



		/* Update unicast entries if host's mailbox is ready */

		if (fm10k_host_mbx_ready(interface))

			hw->mac.ops.update_uc_addr(hw, glort, hw->mac.addr,

						   vid, true, 0);

		fm10k_queue_mac_request(interface, glort,

					hw->mac.addr, vid, true);

	}



	/* update xcast mode before synchronizing addresses if host's mailbox
@@ -1140,6 +1248,13 @@ void fm10k_reset_rx_state(struct fm10k_intfc *interface) 
	struct net_device *netdev = interface->netdev;

	struct fm10k_hw *hw = &interface->hw;



	/* Wait for MAC/VLAN work to finish */

	while (test_bit(__FM10K_MACVLAN_SCHED, interface->state))

		usleep_range(1000, 2000);



	/* Cancel pending MAC/VLAN requests */

	fm10k_clear_macvlan_queue(interface, interface->glort, true);



	fm10k_mbx_lock(interface);



	/* clear the logical port state on lower device if host's mailbox is
@@ -1374,8 +1489,8 @@ static void *fm10k_dfwd_add_station(struct net_device *dev, 
	if (fm10k_host_mbx_ready(interface)) {

		hw->mac.ops.update_xcast_mode(hw, glort,

					      FM10K_XCAST_MODE_MULTI);

		hw->mac.ops.update_uc_addr(hw, glort, sdev->dev_addr,

					   0, true, 0);

		fm10k_queue_mac_request(interface, glort, sdev->dev_addr,

					0, true);

	}



	fm10k_mbx_unlock(interface);
@@ -1414,8 +1529,8 @@ static void fm10k_dfwd_del_station(struct net_device *dev, void *priv) 
	if (fm10k_host_mbx_ready(interface)) {

		hw->mac.ops.update_xcast_mode(hw, glort,

					      FM10K_XCAST_MODE_NONE);

		hw->mac.ops.update_uc_addr(hw, glort, sdev->dev_addr,

					   0, false, 0);

		fm10k_queue_mac_request(interface, glort, sdev->dev_addr,

					0, false);

	}



	fm10k_mbx_unlock(interface);

drivers/net/ethernet/intel/fm10k/fm10k_pci.c

+319 −73

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE