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

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

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



Jeff Kirsher says:

====================
Intel Wired LAN Driver Updates 2015-12-03

This series contains updates to ixgbe and ixgbevf only.

Mark cleans up ixgbe_init_phy_ops_x550em, since this was designed to
initialize function pointers only and moves the KR PHY reset to the
ixgbe_setup_internal_phy_t_x550em which was designed to detect which
mode the PHY operates in and set it up.  Added the new thermal alarm
type support used with newer X550EM_x devices.  Fixed both ixgbe and
ixgbevf to use a private work queue to avoid hangs, which would
possibly occur when creating and destroying many VFS repeatedly.
Updated ixgbe PTP implementation to accommodate X550EM_x devices,
which handle clocking differently.  Fixed specification violations
in the datasheet, which was reported by Dan Streetman.  Fixed ixgbe
to check for and handle IPv6 extended headers so that Tx checksum
offload can be done, which was reported by Tom Herbert.  Fixed ixgbe
link issue for some systems with X540 or X550 by only inhibiting the
turning PHY power off when manageability is present.

Alex Duyck refactors the MAC address configuration code, which in
turns fixes an issue where once 63 entries had been used, you could no
longer add additional filters.  Updated ixgbe to use __dev_uc_sync
which also resolved an issue in which you could not remove an FDB
address without having to reset the port.  Updated the ixgbe driver
to make use of all the free RAR entries for FDB use if needed.

v2: updated patch 13 to "Alex Duyck Approved" version, in the original
    submission, I had grabbed a previous version of the patch and did not
    catch it was superseded by a later version
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 6f24e5d5 d34a614a

drivers/net/ethernet/intel/ixgbe/ixgbe.h

+39 −7
Original line number Diff line number Diff line
@@ -139,6 +139,7 @@ enum ixgbe_tx_flags { 
#define IXGBE_X540_VF_DEVICE_ID         0x1515



struct vf_data_storage {

	struct pci_dev *vfdev;

	unsigned char vf_mac_addresses[ETH_ALEN];

	u16 vf_mc_hashes[IXGBE_MAX_VF_MC_ENTRIES];

	u16 num_vf_mc_hashes;
@@ -224,6 +225,8 @@ struct ixgbe_rx_queue_stats { 
	u64 csum_err;

};



#define IXGBE_TS_HDR_LEN 8



enum ixgbe_ring_state_t {

	__IXGBE_TX_FDIR_INIT_DONE,

	__IXGBE_TX_XPS_INIT_DONE,
@@ -282,6 +285,8 @@ struct ixgbe_ring { 
	u16 next_to_use;

	u16 next_to_clean;



	unsigned long last_rx_timestamp;



	union {

		u16 next_to_alloc;

		struct {
@@ -587,9 +592,10 @@ static inline u16 ixgbe_desc_unused(struct ixgbe_ring *ring) 


struct ixgbe_mac_addr {

	u8 addr[ETH_ALEN];

	u16 queue;

	u16 pool;

	u16 state; /* bitmask */

};



#define IXGBE_MAC_STATE_DEFAULT		0x1

#define IXGBE_MAC_STATE_MODIFIED	0x2

#define IXGBE_MAC_STATE_IN_USE		0x4
@@ -639,6 +645,8 @@ struct ixgbe_adapter { 
#define IXGBE_FLAG_SRIOV_CAPABLE                (u32)(1 << 22)

#define IXGBE_FLAG_SRIOV_ENABLED                (u32)(1 << 23)

#define IXGBE_FLAG_VXLAN_OFFLOAD_CAPABLE	BIT(24)

#define IXGBE_FLAG_RX_HWTSTAMP_ENABLED		BIT(25)

#define IXGBE_FLAG_RX_HWTSTAMP_IN_REGISTER	BIT(26)



	u32 flags2;

#define IXGBE_FLAG2_RSC_CAPABLE                 (u32)(1 << 0)
@@ -755,9 +763,12 @@ struct ixgbe_adapter { 
	unsigned long last_rx_ptp_check;

	unsigned long last_rx_timestamp;

	spinlock_t tmreg_lock;

	struct cyclecounter cc;

	struct timecounter tc;

	struct cyclecounter hw_cc;

	struct timecounter hw_tc;

	u32 base_incval;

	u32 tx_hwtstamp_timeouts;

	u32 rx_hwtstamp_cleared;

	void (*ptp_setup_sdp)(struct ixgbe_adapter *);



	/* SR-IOV */

	DECLARE_BITMAP(active_vfs, IXGBE_MAX_VF_FUNCTIONS);
@@ -883,9 +894,9 @@ int ixgbe_wol_supported(struct ixgbe_adapter *adapter, u16 device_id, 
void ixgbe_full_sync_mac_table(struct ixgbe_adapter *adapter);

#endif

int ixgbe_add_mac_filter(struct ixgbe_adapter *adapter,

			 u8 *addr, u16 queue);

			 const u8 *addr, u16 queue);

int ixgbe_del_mac_filter(struct ixgbe_adapter *adapter,

			 u8 *addr, u16 queue);

			 const u8 *addr, u16 queue);

void ixgbe_clear_interrupt_scheme(struct ixgbe_adapter *adapter);

netdev_tx_t ixgbe_xmit_frame_ring(struct sk_buff *, struct ixgbe_adapter *,

				  struct ixgbe_ring *);
@@ -968,12 +979,33 @@ void ixgbe_ptp_suspend(struct ixgbe_adapter *adapter); 
void ixgbe_ptp_stop(struct ixgbe_adapter *adapter);

void ixgbe_ptp_overflow_check(struct ixgbe_adapter *adapter);

void ixgbe_ptp_rx_hang(struct ixgbe_adapter *adapter);

void ixgbe_ptp_rx_hwtstamp(struct ixgbe_adapter *adapter, struct sk_buff *skb);

void ixgbe_ptp_rx_pktstamp(struct ixgbe_q_vector *, struct sk_buff *);

void ixgbe_ptp_rx_rgtstamp(struct ixgbe_q_vector *, struct sk_buff *skb);

static inline void ixgbe_ptp_rx_hwtstamp(struct ixgbe_ring *rx_ring,

					 union ixgbe_adv_rx_desc *rx_desc,

					 struct sk_buff *skb)

{

	if (unlikely(ixgbe_test_staterr(rx_desc, IXGBE_RXD_STAT_TSIP))) {

		ixgbe_ptp_rx_pktstamp(rx_ring->q_vector, skb);

		return;

	}



	if (unlikely(!ixgbe_test_staterr(rx_desc, IXGBE_RXDADV_STAT_TS)))

		return;



	ixgbe_ptp_rx_rgtstamp(rx_ring->q_vector, skb);



	/* Update the last_rx_timestamp timer in order to enable watchdog check

	 * for error case of latched timestamp on a dropped packet.

	 */

	rx_ring->last_rx_timestamp = jiffies;

}



int ixgbe_ptp_set_ts_config(struct ixgbe_adapter *adapter, struct ifreq *ifr);

int ixgbe_ptp_get_ts_config(struct ixgbe_adapter *adapter, struct ifreq *ifr);

void ixgbe_ptp_start_cyclecounter(struct ixgbe_adapter *adapter);

void ixgbe_ptp_reset(struct ixgbe_adapter *adapter);

void ixgbe_ptp_check_pps_event(struct ixgbe_adapter *adapter, u32 eicr);

void ixgbe_ptp_check_pps_event(struct ixgbe_adapter *adapter);

#ifdef CONFIG_PCI_IOV

void ixgbe_sriov_reinit(struct ixgbe_adapter *adapter);

#endif

drivers/net/ethernet/intel/ixgbe/ixgbe_82598.c

+3 −2
Original line number Diff line number Diff line 
/*******************************************************************************



  Intel 10 Gigabit PCI Express Linux driver

  Copyright(c) 1999 - 2014 Intel Corporation.

  Copyright(c) 1999 - 2015 Intel Corporation.



  This program is free software; you can redistribute it and/or modify it

  under the terms and conditions of the GNU General Public License,
@@ -765,13 +765,14 @@ static s32 ixgbe_reset_hw_82598(struct ixgbe_hw *hw) 
	ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL) | IXGBE_CTRL_RST;

	IXGBE_WRITE_REG(hw, IXGBE_CTRL, ctrl);

	IXGBE_WRITE_FLUSH(hw);

	usleep_range(1000, 1200);



	/* Poll for reset bit to self-clear indicating reset is complete */

	for (i = 0; i < 10; i++) {

		udelay(1);

		ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL);

		if (!(ctrl & IXGBE_CTRL_RST))

			break;

		udelay(1);

	}

	if (ctrl & IXGBE_CTRL_RST) {

		status = IXGBE_ERR_RESET_FAILED;

drivers/net/ethernet/intel/ixgbe/ixgbe_82599.c

+2 −1
Original line number Diff line number Diff line
@@ -990,13 +990,14 @@ static s32 ixgbe_reset_hw_82599(struct ixgbe_hw *hw) 
	ctrl |= IXGBE_READ_REG(hw, IXGBE_CTRL);

	IXGBE_WRITE_REG(hw, IXGBE_CTRL, ctrl);

	IXGBE_WRITE_FLUSH(hw);

	usleep_range(1000, 1200);



	/* Poll for reset bit to self-clear indicating reset is complete */

	for (i = 0; i < 10; i++) {

		udelay(1);

		ctrl = IXGBE_READ_REG(hw, IXGBE_CTRL);

		if (!(ctrl & IXGBE_CTRL_RST_MASK))

			break;

		udelay(1);

	}



	if (ctrl & IXGBE_CTRL_RST_MASK) {

drivers/net/ethernet/intel/ixgbe/ixgbe_common.c

+13 −1
Original line number Diff line number Diff line 
/*******************************************************************************



  Intel 10 Gigabit PCI Express Linux driver

  Copyright(c) 1999 - 2014 Intel Corporation.

  Copyright(c) 1999 - 2015 Intel Corporation.



  This program is free software; you can redistribute it and/or modify it

  under the terms and conditions of the GNU General Public License,
@@ -2454,6 +2454,17 @@ static s32 ixgbe_disable_pcie_master(struct ixgbe_hw *hw) 
	/* Always set this bit to ensure any future transactions are blocked */

	IXGBE_WRITE_REG(hw, IXGBE_CTRL, IXGBE_CTRL_GIO_DIS);



	/* Poll for bit to read as set */

	for (i = 0; i < IXGBE_PCI_MASTER_DISABLE_TIMEOUT; i++) {

		if (IXGBE_READ_REG(hw, IXGBE_CTRL) & IXGBE_CTRL_GIO_DIS)

			break;

		usleep_range(100, 120);

	}

	if (i >= IXGBE_PCI_MASTER_DISABLE_TIMEOUT) {

		hw_dbg(hw, "GIO disable did not set - requesting resets\n");

		goto gio_disable_fail;

	}



	/* Exit if master requests are blocked */

	if (!(IXGBE_READ_REG(hw, IXGBE_STATUS) & IXGBE_STATUS_GIO) ||

	    ixgbe_removed(hw->hw_addr))
@@ -2475,6 +2486,7 @@ static s32 ixgbe_disable_pcie_master(struct ixgbe_hw *hw) 
	 * again to clear out any effects they may have had on our device.

	 */

	hw_dbg(hw, "GIO Master Disable bit didn't clear - requesting resets\n");

gio_disable_fail:

	hw->mac.flags |= IXGBE_FLAGS_DOUBLE_RESET_REQUIRED;



	if (hw->mac.type >= ixgbe_mac_X550)

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

+168 −105
Original line number Diff line number Diff line
@@ -172,6 +172,8 @@ MODULE_DESCRIPTION("Intel(R) 10 Gigabit PCI Express Network Driver"); 
MODULE_LICENSE("GPL");

MODULE_VERSION(DRV_VERSION);



static struct workqueue_struct *ixgbe_wq;



static bool ixgbe_check_cfg_remove(struct ixgbe_hw *hw, struct pci_dev *pdev);



static int ixgbe_read_pci_cfg_word_parent(struct ixgbe_adapter *adapter,
@@ -313,7 +315,7 @@ static void ixgbe_service_event_schedule(struct ixgbe_adapter *adapter) 
	if (!test_bit(__IXGBE_DOWN, &adapter->state) &&

	    !test_bit(__IXGBE_REMOVING, &adapter->state) &&

	    !test_and_set_bit(__IXGBE_SERVICE_SCHED, &adapter->state))

		schedule_work(&adapter->service_task);

		queue_work(ixgbe_wq, &adapter->service_task);

}



static void ixgbe_remove_adapter(struct ixgbe_hw *hw)
@@ -1632,6 +1634,7 @@ static void ixgbe_process_skb_fields(struct ixgbe_ring *rx_ring, 
				     struct sk_buff *skb)

{

	struct net_device *dev = rx_ring->netdev;

	u32 flags = rx_ring->q_vector->adapter->flags;



	ixgbe_update_rsc_stats(rx_ring, skb);
@@ -1639,8 +1642,8 @@ static void ixgbe_process_skb_fields(struct ixgbe_ring *rx_ring, 


	ixgbe_rx_checksum(rx_ring, rx_desc, skb);



	if (unlikely(ixgbe_test_staterr(rx_desc, IXGBE_RXDADV_STAT_TS)))

		ixgbe_ptp_rx_hwtstamp(rx_ring->q_vector->adapter, skb);

	if (unlikely(flags & IXGBE_FLAG_RX_HWTSTAMP_ENABLED))

		ixgbe_ptp_rx_hwtstamp(rx_ring, rx_desc, skb);



	if ((dev->features & NETIF_F_HW_VLAN_CTAG_RX) &&

	    ixgbe_test_staterr(rx_desc, IXGBE_RXD_STAT_VP)) {
@@ -2738,7 +2741,7 @@ static irqreturn_t ixgbe_msix_other(int irq, void *data) 
	ixgbe_check_fan_failure(adapter, eicr);



	if (unlikely(eicr & IXGBE_EICR_TIMESYNC))

		ixgbe_ptp_check_pps_event(adapter, eicr);

		ixgbe_ptp_check_pps_event(adapter);



	/* re-enable the original interrupt state, no lsc, no queues */

	if (!test_bit(__IXGBE_DOWN, &adapter->state))
@@ -2945,7 +2948,7 @@ static irqreturn_t ixgbe_intr(int irq, void *data) 


	ixgbe_check_fan_failure(adapter, eicr);

	if (unlikely(eicr & IXGBE_EICR_TIMESYNC))

		ixgbe_ptp_check_pps_event(adapter, eicr);

		ixgbe_ptp_check_pps_event(adapter);



	/* would disable interrupts here but EIAM disabled it */

	napi_schedule_irqoff(&q_vector->napi);
@@ -4029,124 +4032,156 @@ static int ixgbe_write_mc_addr_list(struct net_device *netdev) 
#ifdef CONFIG_PCI_IOV

void ixgbe_full_sync_mac_table(struct ixgbe_adapter *adapter)

{

	struct ixgbe_mac_addr *mac_table = &adapter->mac_table[0];

	struct ixgbe_hw *hw = &adapter->hw;

	int i;

	for (i = 0; i < hw->mac.num_rar_entries; i++) {

		if (adapter->mac_table[i].state & IXGBE_MAC_STATE_IN_USE)

			hw->mac.ops.set_rar(hw, i, adapter->mac_table[i].addr,

					    adapter->mac_table[i].queue,



	for (i = 0; i < hw->mac.num_rar_entries; i++, mac_table++) {

		mac_table->state &= ~IXGBE_MAC_STATE_MODIFIED;



		if (mac_table->state & IXGBE_MAC_STATE_IN_USE)

			hw->mac.ops.set_rar(hw, i,

					    mac_table->addr,

					    mac_table->pool,

					    IXGBE_RAH_AV);

		else

			hw->mac.ops.clear_rar(hw, i);



		adapter->mac_table[i].state &= ~(IXGBE_MAC_STATE_MODIFIED);

	}

}

#endif



#endif

static void ixgbe_sync_mac_table(struct ixgbe_adapter *adapter)

{

	struct ixgbe_mac_addr *mac_table = &adapter->mac_table[0];

	struct ixgbe_hw *hw = &adapter->hw;

	int i;

	for (i = 0; i < hw->mac.num_rar_entries; i++) {

		if (adapter->mac_table[i].state & IXGBE_MAC_STATE_MODIFIED) {

			if (adapter->mac_table[i].state &

			    IXGBE_MAC_STATE_IN_USE)



	for (i = 0; i < hw->mac.num_rar_entries; i++, mac_table++) {

		if (!(mac_table->state & IXGBE_MAC_STATE_MODIFIED))

			continue;



		mac_table->state &= ~IXGBE_MAC_STATE_MODIFIED;



		if (mac_table->state & IXGBE_MAC_STATE_IN_USE)

			hw->mac.ops.set_rar(hw, i,

						adapter->mac_table[i].addr,

						adapter->mac_table[i].queue,

					    mac_table->addr,

					    mac_table->pool,

					    IXGBE_RAH_AV);

		else

			hw->mac.ops.clear_rar(hw, i);



			adapter->mac_table[i].state &=

						~(IXGBE_MAC_STATE_MODIFIED);

		}

	}

}



static void ixgbe_flush_sw_mac_table(struct ixgbe_adapter *adapter)

{

	int i;

	struct ixgbe_mac_addr *mac_table = &adapter->mac_table[0];

	struct ixgbe_hw *hw = &adapter->hw;

	int i;



	for (i = 0; i < hw->mac.num_rar_entries; i++) {

		adapter->mac_table[i].state |= IXGBE_MAC_STATE_MODIFIED;

		adapter->mac_table[i].state &= ~IXGBE_MAC_STATE_IN_USE;

		eth_zero_addr(adapter->mac_table[i].addr);

		adapter->mac_table[i].queue = 0;

	for (i = 0; i < hw->mac.num_rar_entries; i++, mac_table++) {

		mac_table->state |= IXGBE_MAC_STATE_MODIFIED;

		mac_table->state &= ~IXGBE_MAC_STATE_IN_USE;

	}



	ixgbe_sync_mac_table(adapter);

}



static int ixgbe_available_rars(struct ixgbe_adapter *adapter)

static int ixgbe_available_rars(struct ixgbe_adapter *adapter, u16 pool)

{

	struct ixgbe_mac_addr *mac_table = &adapter->mac_table[0];

	struct ixgbe_hw *hw = &adapter->hw;

	int i, count = 0;



	for (i = 0; i < hw->mac.num_rar_entries; i++) {

		if (adapter->mac_table[i].state == 0)

	for (i = 0; i < hw->mac.num_rar_entries; i++, mac_table++) {

		/* do not count default RAR as available */

		if (mac_table->state & IXGBE_MAC_STATE_DEFAULT)

			continue;



		/* only count unused and addresses that belong to us */

		if (mac_table->state & IXGBE_MAC_STATE_IN_USE) {

			if (mac_table->pool != pool)

				continue;

		}



		count++;

	}



	return count;

}



/* this function destroys the first RAR entry */

static void ixgbe_mac_set_default_filter(struct ixgbe_adapter *adapter,

					 u8 *addr)

static void ixgbe_mac_set_default_filter(struct ixgbe_adapter *adapter)

{

	struct ixgbe_mac_addr *mac_table = &adapter->mac_table[0];

	struct ixgbe_hw *hw = &adapter->hw;



	memcpy(&adapter->mac_table[0].addr, addr, ETH_ALEN);

	adapter->mac_table[0].queue = VMDQ_P(0);

	adapter->mac_table[0].state = (IXGBE_MAC_STATE_DEFAULT |

				       IXGBE_MAC_STATE_IN_USE);

	hw->mac.ops.set_rar(hw, 0, adapter->mac_table[0].addr,

			    adapter->mac_table[0].queue,

	memcpy(&mac_table->addr, hw->mac.addr, ETH_ALEN);

	mac_table->pool = VMDQ_P(0);



	mac_table->state = IXGBE_MAC_STATE_DEFAULT | IXGBE_MAC_STATE_IN_USE;



	hw->mac.ops.set_rar(hw, 0, mac_table->addr, mac_table->pool,

			    IXGBE_RAH_AV);

}



int ixgbe_add_mac_filter(struct ixgbe_adapter *adapter, u8 *addr, u16 queue)

int ixgbe_add_mac_filter(struct ixgbe_adapter *adapter,

			 const u8 *addr, u16 pool)

{

	struct ixgbe_mac_addr *mac_table = &adapter->mac_table[0];

	struct ixgbe_hw *hw = &adapter->hw;

	int i;



	if (is_zero_ether_addr(addr))

		return -EINVAL;



	for (i = 0; i < hw->mac.num_rar_entries; i++) {

		if (adapter->mac_table[i].state & IXGBE_MAC_STATE_IN_USE)

	for (i = 0; i < hw->mac.num_rar_entries; i++, mac_table++) {

		if (mac_table->state & IXGBE_MAC_STATE_IN_USE)

			continue;

		adapter->mac_table[i].state |= (IXGBE_MAC_STATE_MODIFIED |

						IXGBE_MAC_STATE_IN_USE);

		ether_addr_copy(adapter->mac_table[i].addr, addr);

		adapter->mac_table[i].queue = queue;



		ether_addr_copy(mac_table->addr, addr);

		mac_table->pool = pool;



		mac_table->state |= IXGBE_MAC_STATE_MODIFIED |

				    IXGBE_MAC_STATE_IN_USE;



		ixgbe_sync_mac_table(adapter);



		return i;

	}



	return -ENOMEM;

}



int ixgbe_del_mac_filter(struct ixgbe_adapter *adapter, u8 *addr, u16 queue)

int ixgbe_del_mac_filter(struct ixgbe_adapter *adapter,

			 const u8 *addr, u16 pool)

{

	/* search table for addr, if found, set to 0 and sync */

	int i;

	struct ixgbe_mac_addr *mac_table = &adapter->mac_table[0];

	struct ixgbe_hw *hw = &adapter->hw;

	int i;



	if (is_zero_ether_addr(addr))

		return -EINVAL;



	for (i = 0; i < hw->mac.num_rar_entries; i++) {

		if (ether_addr_equal(addr, adapter->mac_table[i].addr) &&

		    adapter->mac_table[i].queue == queue) {

			adapter->mac_table[i].state |= IXGBE_MAC_STATE_MODIFIED;

			adapter->mac_table[i].state &= ~IXGBE_MAC_STATE_IN_USE;

			eth_zero_addr(adapter->mac_table[i].addr);

			adapter->mac_table[i].queue = 0;

	/* search table for addr, if found clear IN_USE flag and sync */

	for (i = 0; i < hw->mac.num_rar_entries; i++, mac_table++) {

		/* we can only delete an entry if it is in use */

		if (!(mac_table->state & IXGBE_MAC_STATE_IN_USE))

			continue;

		/* we only care about entries that belong to the given pool */

		if (mac_table->pool != pool)

			continue;

		/* we only care about a specific MAC address */

		if (!ether_addr_equal(addr, mac_table->addr))

			continue;



		mac_table->state |= IXGBE_MAC_STATE_MODIFIED;

		mac_table->state &= ~IXGBE_MAC_STATE_IN_USE;



		ixgbe_sync_mac_table(adapter);



		return 0;

	}

	}



	return -ENOMEM;

}

/**
@@ -4164,7 +4199,7 @@ static int ixgbe_write_uc_addr_list(struct net_device *netdev, int vfn) 
	int count = 0;



	/* return ENOMEM indicating insufficient memory for addresses */

	if (netdev_uc_count(netdev) > ixgbe_available_rars(adapter))

	if (netdev_uc_count(netdev) > ixgbe_available_rars(adapter, vfn))

		return -ENOMEM;



	if (!netdev_uc_empty(netdev)) {
@@ -4178,6 +4213,25 @@ static int ixgbe_write_uc_addr_list(struct net_device *netdev, int vfn) 
	return count;

}



static int ixgbe_uc_sync(struct net_device *netdev, const unsigned char *addr)

{

	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	int ret;



	ret = ixgbe_add_mac_filter(adapter, addr, VMDQ_P(0));



	return min_t(int, ret, 0);

}



static int ixgbe_uc_unsync(struct net_device *netdev, const unsigned char *addr)

{

	struct ixgbe_adapter *adapter = netdev_priv(netdev);



	ixgbe_del_mac_filter(adapter, addr, VMDQ_P(0));



	return 0;

}



/**

 * ixgbe_set_rx_mode - Unicast, Multicast and Promiscuous mode set

 * @netdev: network interface device structure
@@ -4233,8 +4287,7 @@ void ixgbe_set_rx_mode(struct net_device *netdev) 
	 * sufficient space to store all the addresses then enable

	 * unicast promiscuous mode

	 */

	count = ixgbe_write_uc_addr_list(netdev, VMDQ_P(0));

	if (count < 0) {

	if (__dev_uc_sync(netdev, ixgbe_uc_sync, ixgbe_uc_unsync)) {

		fctrl |= IXGBE_FCTRL_UPE;

		vmolr |= IXGBE_VMOLR_ROPE;

	}
@@ -5037,7 +5090,6 @@ void ixgbe_reset(struct ixgbe_adapter *adapter) 
	struct ixgbe_hw *hw = &adapter->hw;

	struct net_device *netdev = adapter->netdev;

	int err;

	u8 old_addr[ETH_ALEN];



	if (ixgbe_removed(hw->hw_addr))

		return;
@@ -5073,10 +5125,13 @@ void ixgbe_reset(struct ixgbe_adapter *adapter) 
	}



	clear_bit(__IXGBE_IN_SFP_INIT, &adapter->state);

	/* do not flush user set addresses */

	memcpy(old_addr, &adapter->mac_table[0].addr, netdev->addr_len);



	/* flush entries out of MAC table */

	ixgbe_flush_sw_mac_table(adapter);

	ixgbe_mac_set_default_filter(adapter, old_addr);

	__dev_uc_unsync(netdev, NULL);



	/* do not flush user set addresses */

	ixgbe_mac_set_default_filter(adapter);



	/* update SAN MAC vmdq pool selection */

	if (hw->mac.san_mac_rar_index)
@@ -6611,10 +6666,8 @@ static void ixgbe_check_for_bad_vf(struct ixgbe_adapter *adapter) 
{

	struct ixgbe_hw *hw = &adapter->hw;

	struct pci_dev *pdev = adapter->pdev;

	struct pci_dev *vfdev;

	unsigned int vf;

	u32 gpc;

	int pos;

	unsigned short vf_id;



	if (!(netif_carrier_ok(adapter->netdev)))

		return;
@@ -6631,27 +6684,18 @@ static void ixgbe_check_for_bad_vf(struct ixgbe_adapter *adapter) 
	if (!pdev)

		return;



	pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV);

	if (!pos)

		return;



	/* get the device ID for the VF */

	pci_read_config_word(pdev, pos + PCI_SRIOV_VF_DID, &vf_id);



	/* check status reg for all VFs owned by this PF */

	vfdev = pci_get_device(pdev->vendor, vf_id, NULL);

	while (vfdev) {

		if (vfdev->is_virtfn && (vfdev->physfn == pdev)) {

	for (vf = 0; vf < adapter->num_vfs; ++vf) {

		struct pci_dev *vfdev = adapter->vfinfo[vf].vfdev;

		u16 status_reg;



		if (!vfdev)

			continue;

		pci_read_config_word(vfdev, PCI_STATUS, &status_reg);

			if (status_reg & PCI_STATUS_REC_MASTER_ABORT)

				/* issue VFLR */

		if (status_reg != IXGBE_FAILED_READ_CFG_WORD &&

		    status_reg & PCI_STATUS_REC_MASTER_ABORT)

			ixgbe_issue_vf_flr(adapter, vfdev);

	}



		vfdev = pci_get_device(pdev->vendor, vf_id, vfdev);

	}

}



static void ixgbe_spoof_check(struct ixgbe_adapter *adapter)
@@ -7019,6 +7063,7 @@ static void ixgbe_tx_csum(struct ixgbe_ring *tx_ring, 
			struct tcphdr *tcphdr;

			u8 *raw;

		} transport_hdr;

		__be16 frag_off;



		if (skb->encapsulation) {

			network_hdr.raw = skb_inner_network_header(skb);
@@ -7042,13 +7087,17 @@ static void ixgbe_tx_csum(struct ixgbe_ring *tx_ring, 
		case 6:

			vlan_macip_lens |= transport_hdr.raw - network_hdr.raw;

			l4_hdr = network_hdr.ipv6->nexthdr;

			if (likely((transport_hdr.raw - network_hdr.raw) ==

				   sizeof(struct ipv6hdr)))

				break;

			ipv6_skip_exthdr(skb, network_hdr.raw - skb->data +

					      sizeof(struct ipv6hdr),

					 &l4_hdr, &frag_off);

			if (unlikely(frag_off))

				l4_hdr = NEXTHDR_FRAGMENT;

			break;

		default:

			if (unlikely(net_ratelimit())) {

				dev_warn(tx_ring->dev,

					 "partial checksum but version=%d\n",

					 network_hdr.ipv4->version);

			}

			break;

		}



		switch (l4_hdr) {
@@ -7069,16 +7118,18 @@ static void ixgbe_tx_csum(struct ixgbe_ring *tx_ring, 
		default:

			if (unlikely(net_ratelimit())) {

				dev_warn(tx_ring->dev,

				 "partial checksum but l4 proto=%x!\n",

				 l4_hdr);

					 "partial checksum, version=%d, l4 proto=%x\n",

					 network_hdr.ipv4->version, l4_hdr);

			}

			break;

			skb_checksum_help(skb);

			goto no_csum;

		}



		/* update TX checksum flag */

		first->tx_flags |= IXGBE_TX_FLAGS_CSUM;

	}



no_csum:

	/* vlan_macip_lens: MACLEN, VLAN tag */

	vlan_macip_lens |= first->tx_flags & IXGBE_TX_FLAGS_VLAN_MASK;
@@ -7654,17 +7705,16 @@ static int ixgbe_set_mac(struct net_device *netdev, void *p) 
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	struct ixgbe_hw *hw = &adapter->hw;

	struct sockaddr *addr = p;

	int ret;



	if (!is_valid_ether_addr(addr->sa_data))

		return -EADDRNOTAVAIL;



	ixgbe_del_mac_filter(adapter, hw->mac.addr, VMDQ_P(0));

	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);

	memcpy(hw->mac.addr, addr->sa_data, netdev->addr_len);



	ret = ixgbe_add_mac_filter(adapter, hw->mac.addr, VMDQ_P(0));

	return ret > 0 ? 0 : ret;

	ixgbe_mac_set_default_filter(adapter);



	return 0;

}



static int
@@ -8147,7 +8197,10 @@ static int ixgbe_ndo_fdb_add(struct ndmsg *ndm, struct nlattr *tb[], 
{

	/* guarantee we can provide a unique filter for the unicast address */

	if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr)) {

		if (IXGBE_MAX_PF_MACVLANS <= netdev_uc_count(dev))

		struct ixgbe_adapter *adapter = netdev_priv(dev);

		u16 pool = VMDQ_P(0);



		if (netdev_uc_count(dev) >= ixgbe_available_rars(adapter, pool))

			return -ENOMEM;

	}
@@ -8865,7 +8918,7 @@ static int ixgbe_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 
		goto err_sw_init;

	}



	ixgbe_mac_set_default_filter(adapter, hw->mac.perm_addr);

	ixgbe_mac_set_default_filter(adapter);



	setup_timer(&adapter->service_timer, &ixgbe_service_timer,

		    (unsigned long) adapter);
@@ -9320,6 +9373,12 @@ static int __init ixgbe_init_module(void) 
	pr_info("%s - version %s\n", ixgbe_driver_string, ixgbe_driver_version);

	pr_info("%s\n", ixgbe_copyright);



	ixgbe_wq = create_singlethread_workqueue(ixgbe_driver_name);

	if (!ixgbe_wq) {

		pr_err("%s: Failed to create workqueue\n", ixgbe_driver_name);

		return -ENOMEM;

	}



	ixgbe_dbg_init();



	ret = pci_register_driver(&ixgbe_driver);
@@ -9351,6 +9410,10 @@ static void __exit ixgbe_exit_module(void) 
	pci_unregister_driver(&ixgbe_driver);



	ixgbe_dbg_exit();

	if (ixgbe_wq) {

		destroy_workqueue(ixgbe_wq);

		ixgbe_wq = NULL;

	}

}



#ifdef CONFIG_IXGBE_DCA