Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Pull networking fixes from David Miller: 1) mlx4 driver bug fixes (TX queue wakeups, csum complete indications) from Ido Shamay, Eran Ben Elisha, and Or Gerlitz. 2) Missing unlock in error path of PTP support in renesas driver, from Dan Carpenter. 3) Add Vitesse 8641 phy IDs to vitesse PHY driver, from Shaohui Xie. 4) Bnx2x driver bug fixes (linearization of encap packets, scratchpad parity error notifications, flow-control and speed settings) from Yuval Mintz, Manish Chopra, Shahed Shaikh, and Ariel Elior. 5) ipv6 extension header parsing in the igb chip has a HW errata, disable it. Frm Todd Fujinaka. 6) Fix PCI link state locking issue in e1000e driver, from Yanir Lubetkin. 7) Cure panics during MTU change in i40e, from Mitch Williams. 8) Don't leak promisc refs in DSA slave driver, from Gilad Ben-Yossef. 9) Add missing HAS_DMA dep to VIA Rhine driver, from Geery Uytterhoeven. 10) Make sure DMA map/unmap calls are symmetric in bnx2x driver, from Michal Schmidt. 11) Workaround for MDIO access problems in bcm7xxx devices, from FLorian Fainelli. 12) Fix races in SCTP protocol between OTTB responses and route removals, from Alexander Sverdlin. 13) Fix jumbo frame checksum issue with some mvneta devices, from Simon Guinot. * git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (58 commits) sock_diag: don't broadcast kernel sockets net: mvneta: disable IP checksum with jumbo frames for Armada 370 ARM: mvebu: update Ethernet compatible string for Armada XP net: mvneta: introduce compatible string "marvell, armada-xp-neta" api: fix compatibility of linux/in.h with netinet/in.h net: icplus: fix typo in constant name sis900: Trivial: Fix typos in enums stmmac: Trivial: fix typo in constant name sctp: Fix race between OOTB responce and route removal net-Liquidio: Delete unnecessary checks before the function call "vfree" vmxnet3: Bump up driver version number amd-xgbe: Add the __GFP_NOWARN flag to Rx buffer allocation net: phy: mdio-bcm-unimac: workaround initial read failures for integrated PHYs net: bcmgenet: workaround initial read failures for integrated PHYs net: phy: bcm7xxx: workaround MDIO management controller initial read bnx2x: fix DMA API usage net: via: VIA_RHINE and VIA_VELOCITY should depend on HAS_DMA net/phy: tune get_phy_c45_ids to support more c45 phy bnx2x: fix lockdep splat net: fec: don't access RACC register when not available ...

Linus Torvalds committed 11 years ago

Commit 47ebed92 parents 44b061f b92262269 files · +701 −376Browse files

Unified · Split

69 files

Documentation/devicetree/bindings/net/marvell-armada-370-neta.txt +1 −1
arch/arm/boot/dts/armada-370-xp.dtsi +0 −2
arch/arm/boot/dts/armada-370.dtsi +8 −0
arch/arm/boot/dts/armada-xp-mv78260.dtsi +1 −1
arch/arm/boot/dts/armada-xp-mv78460.dtsi +1 −1
arch/arm/boot/dts/armada-xp.dtsi +9 −1
drivers/net/ethernet/amd/xgbe/xgbe-desc.c +1 −1
drivers/net/ethernet/apm/xgene/xgene_enet_main.c +1 −1
drivers/net/ethernet/broadcom/bnx2x/bnx2x.h +7 −5
drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c +17 −15
drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h +2 −10
drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c +43 −15
drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c +32 −11
drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c +41 −19
drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c +1 −1
drivers/net/ethernet/broadcom/genet/bcmgenet.h +1 −0
drivers/net/ethernet/broadcom/genet/bcmmii.c +50 −4
drivers/net/ethernet/cavium/liquidio/lio_ethtool.c +3 −2
drivers/net/ethernet/cavium/liquidio/octeon_device.c +3 −8
drivers/net/ethernet/cavium/liquidio/octeon_droq.c +1 −3
drivers/net/ethernet/cavium/liquidio/request_manager.c +1 −2
drivers/net/ethernet/cisco/enic/enic_main.c +2 −2
drivers/net/ethernet/cisco/enic/vnic_rq.h +27 −64
drivers/net/ethernet/freescale/Kconfig +2 −2
drivers/net/ethernet/freescale/fec.h +2 −0
drivers/net/ethernet/freescale/fec_main.c +17 −13
drivers/net/ethernet/icplus/ipg.c +1 −1
drivers/net/ethernet/icplus/ipg.h +1 −1
drivers/net/ethernet/intel/e1000e/ich8lan.c +98 −28
drivers/net/ethernet/intel/e1000e/netdev.c +34 −4
drivers/net/ethernet/intel/i40evf/i40e_txrx.c +4 −0
drivers/net/ethernet/intel/i40evf/i40evf.h +0 −1
drivers/net/ethernet/intel/i40evf/i40evf_ethtool.c +4 −2
drivers/net/ethernet/intel/i40evf/i40evf_main.c +47 −63
drivers/net/ethernet/intel/igb/e1000_82575.c +8 −4
drivers/net/ethernet/intel/igb/e1000_defines.h +2 −1
drivers/net/ethernet/intel/igb/igb_main.c +1 −1
drivers/net/ethernet/marvell/mvneta.c +26 −1
drivers/net/ethernet/mellanox/mlx4/en_netdev.c +0 −4
drivers/net/ethernet/mellanox/mlx4/en_rx.c +6 −11
drivers/net/ethernet/mellanox/mlx4/en_tx.c +12 −8
drivers/net/ethernet/mellanox/mlx4/intf.c +7 −1
drivers/net/ethernet/mellanox/mlx4/mlx4_en.h +1 −1
drivers/net/ethernet/renesas/ravb_ptp.c +3 −1
drivers/net/ethernet/sis/sis900.h +2 −2
drivers/net/ethernet/stmicro/stmmac/mmc_core.c +2 −2
drivers/net/ethernet/via/Kconfig +2 −0
drivers/net/phy/bcm7xxx.c +7 −0
drivers/net/phy/mdio-bcm-unimac.c +43 −0
drivers/net/phy/phy_device.c +17 −8
drivers/net/phy/vitesse.c +14 −0
drivers/net/vmxnet3/vmxnet3_int.h +2 −2
drivers/net/xen-netfront.c +0 −7
include/net/ax25.h +15 −1
include/net/sock.h +0 −2
include/uapi/linux/in.h +13 −3
include/uapi/linux/libc-compat.h +22 −0
net/ax25/af_ax25.c +15 −15
net/ax25/ax25_in.c +1 −1
net/core/flow_dissector.c +1 −1
net/core/sock.c +1 −2
net/dsa/slave.c +1 −1
net/ipv4/fib_semantics.c +2 −2
net/sched/cls_flower.c +2 −2
net/sctp/output.c +3 −1
net/sctp/socket.c +0 −6
net/tipc/bcast.c +5 −0
net/tipc/link.c +1 −1
net/tipc/link.h +1 −0

Documentation/devicetree/bindings/net/marvell-armada-370-neta.txt+1−1

@@ -1,7 +1,7 @@
1	* Marvell Armada 370 / Armada XP Ethernet Controller (NETA)	1	* Marvell Armada 370 / Armada XP Ethernet Controller (NETA)
2		2
3	Required properties:	3	Required properties:
4	- compatible: should be "marvell,armada-370-neta".	4	- compatible: "marvell,armada-370-neta" or "marvell,armada-xp-neta".
5	- reg: address and length of the register set for the device.	5	- reg: address and length of the register set for the device.
6	- interrupts: interrupt for the device	6	- interrupts: interrupt for the device
7	- phy: See ethernet.txt file in the same directory.	7	- phy: See ethernet.txt file in the same directory.

arch/arm/boot/dts/armada-370-xp.dtsi+0−2

 			};
 			eth0: ethernet@70000 {
-				compatible = "marvell,armada-370-neta";
 				reg = <0x70000 0x4000>;
 				interrupts = <8>;
 				clocks = <&gateclk 4>;
 			};
 			eth1: ethernet@74000 {
-				compatible = "marvell,armada-370-neta";
 				reg = <0x74000 0x4000>;
 				interrupts = <10>;
 				clocks = <&gateclk 3>;

arch/arm/boot/dts/armada-370.dtsi+8−0

@@ -311,6 +311,14 @@ · 310 unmodified lines
311	dmacap,memset;	311	dmacap,memset;
312	};	312	};
313	};	313	};
		314
		315	ethernet@70000 {
		316	compatible = "marvell,armada-370-neta";
		317	};
		318
		319	ethernet@74000 {
		320	compatible = "marvell,armada-370-neta";
		321	};
314	};	322	};
315	};	323	};
316	};	324	};

arch/arm/boot/dts/armada-xp-mv78260.dtsi+1−1

@@ -318,7 +318,7 @@ · 317 unmodified lines
318	};	318	};
319		319
320	eth3: ethernet@34000 {	320	eth3: ethernet@34000 {
321	compatible = "marvell,armada-370-neta";	321	compatible = "marvell,armada-xp-neta";
322	reg = <0x34000 0x4000>;	322	reg = <0x34000 0x4000>;
323	interrupts = <14>;	323	interrupts = <14>;
324	clocks = <&gateclk 1>;	324	clocks = <&gateclk 1>;

arch/arm/boot/dts/armada-xp-mv78460.dtsi+1−1

@@ -356,7 +356,7 @@ · 355 unmodified lines
356	};	356	};
357		357
358	eth3: ethernet@34000 {	358	eth3: ethernet@34000 {
359	compatible = "marvell,armada-370-neta";	359	compatible = "marvell,armada-xp-neta";
360	reg = <0x34000 0x4000>;	360	reg = <0x34000 0x4000>;
361	interrupts = <14>;	361	interrupts = <14>;
362	clocks = <&gateclk 1>;	362	clocks = <&gateclk 1>;

arch/arm/boot/dts/armada-xp.dtsi+9−1

 			};
 			eth2: ethernet@30000 {
-				compatible = "marvell,armada-370-neta";
+				compatible = "marvell,armada-xp-neta";
 				reg = <0x30000 0x4000>;
 				interrupts = <12>;
 				clocks = <&gateclk 2>;
 				};
 			};
+			ethernet@70000 {
+				compatible = "marvell,armada-xp-neta";
+			};
+			ethernet@74000 {
+				compatible = "marvell,armada-xp-neta";
+			};
 			xor@f0900 {
 				compatible = "marvell,orion-xor";
 				reg = <0xF0900 0x100

drivers/net/ethernet/amd/xgbe/xgbe-desc.c+1−1

@@ -268,7 +268,7 @@ static int xgbe_alloc_pages(struct xgbe_prv_data *pdata, · 267 unmodified lines
268	int ret;	268	int ret;
269		269
270	/* Try to obtain pages, decreasing order if necessary */	270	/* Try to obtain pages, decreasing order if necessary */
271	gfp \|= __GFP_COLD \| __GFP_COMP;	271	gfp \|= __GFP_COLD \| __GFP_COMP \| __GFP_NOWARN;
272	while (order >= 0) {	272	while (order >= 0) {
273	pages = alloc_pages(gfp, order);	273	pages = alloc_pages(gfp, order);
274	if (pages)	274	if (pages)

drivers/net/ethernet/apm/xgene/xgene_enet_main.c+1−1

@@ -948,7 +948,7 @@ static int xgene_enet_get_resources(struct xgene_enet_pdata *pdata) · 947 unmodified lines
948	struct resource *res;	948	struct resource *res;
949	void __iomem *base_addr;	949	void __iomem *base_addr;
950	u32 offset;	950	u32 offset;
951	int ret;	951	int ret = 0;
952		952
953	pdev = pdata->pdev;	953	pdev = pdata->pdev;
954	dev = &pdev->dev;	954	dev = &pdev->dev;

drivers/net/ethernet/broadcom/bnx2x/bnx2x.h+7−5

 struct bnx2x_alloc_pool {
 	struct page	*page;
-	dma_addr_t	dma;
 	unsigned int	offset;
 };
 				 AEU_INPUTS_ATTN_BITS_IGU_PARITY_ERROR | \
 				 AEU_INPUTS_ATTN_BITS_MISC_PARITY_ERROR)
-#define HW_PRTY_ASSERT_SET_3 (AEU_INPUTS_ATTN_BITS_MCP_LATCHED_ROM_PARITY | \
+#define HW_PRTY_ASSERT_SET_3_WITHOUT_SCPAD \
-		AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_RX_PARITY | \
+		(AEU_INPUTS_ATTN_BITS_MCP_LATCHED_ROM_PARITY | \
-		AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_TX_PARITY | \
+		 AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_RX_PARITY | \
-		AEU_INPUTS_ATTN_BITS_MCP_LATCHED_SCPAD_PARITY)
+		 AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_TX_PARITY)
+#define HW_PRTY_ASSERT_SET_3 (HW_PRTY_ASSERT_SET_3_WITHOUT_SCPAD | \
+			      AEU_INPUTS_ATTN_BITS_MCP_LATCHED_SCPAD_PARITY)
 #define HW_PRTY_ASSERT_SET_4 (AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR | \
 			      AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR)

drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c+17−15

 			return -ENOMEM;
 		}
-		pool->dma = dma_map_page(&bp->pdev->dev, pool->page, 0,
-					 PAGE_SIZE, DMA_FROM_DEVICE);
-		if (unlikely(dma_mapping_error(&bp->pdev->dev,
-					       pool->dma))) {
-			__free_pages(pool->page, PAGES_PER_SGE_SHIFT);
-			pool->page = NULL;
-			BNX2X_ERR("Can't map sge\n");
-			return -ENOMEM;
-		}
 		pool->offset = 0;
 	}
+	mapping = dma_map_page(&bp->pdev->dev, pool->page,
+			       pool->offset, SGE_PAGE_SIZE, DMA_FROM_DEVICE);
+	if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
+		BNX2X_ERR("Can't map sge\n");
+		return -ENOMEM;
+	}
 	get_page(pool->page);
 	sw_buf->page = pool->page;
 	sw_buf->offset = pool->offset;
-	mapping = pool->dma + sw_buf->offset;
 	dma_unmap_addr_set(sw_buf, mapping, mapping);
 	sge->addr_hi = cpu_to_le32(U64_HI(mapping));
 			return err;
 		}
-		dma_unmap_single(&bp->pdev->dev,
+		dma_unmap_page(&bp->pdev->dev,
-				 dma_unmap_addr(&old_rx_pg, mapping),
+			       dma_unmap_addr(&old_rx_pg, mapping),
-				 SGE_PAGE_SIZE, DMA_FROM_DEVICE);
+			       SGE_PAGE_SIZE, DMA_FROM_DEVICE);
 		/* Add one frag and update the appropriate fields in the skb */
 		if (fp->mode == TPA_MODE_LRO)
 			skb_fill_page_desc(skb, j, old_rx_pg.page,
 			u32 wnd_sum = 0;
 			/* Headers length */
-			hlen = (int)(skb_transport_header(skb) - skb->data) +
+			if (xmit_type & XMIT_GSO_ENC)
-				tcp_hdrlen(skb);
+				hlen = (int)(skb_inner_transport_header(skb) -
+					     skb->data) +
+					     inner_tcp_hdrlen(skb);
+			else
+				hlen = (int)(skb_transport_header(skb) -
+					     skb->data) + tcp_hdrlen(skb);
 			/* Amount of data (w/o headers) on linear part of SKB*/
 			first_bd_sz = skb_headlen(skb) - hlen;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h+2−10

 	/* Since many fragments can share the same page, make sure to
 	 * only unmap and free the page once.
 	 */
-	dma_unmap_single(&bp->pdev->dev, dma_unmap_addr(sw_buf, mapping),
+	dma_unmap_page(&bp->pdev->dev, dma_unmap_addr(sw_buf, mapping),
-			 SGE_PAGE_SIZE, DMA_FROM_DEVICE);
+		       SGE_PAGE_SIZE, DMA_FROM_DEVICE);
 	put_page(page);
 	if (!pool->page)
 		return;
-	/* Page was not fully fragmented.  Unmap unused space */
-	if (pool->offset < PAGE_SIZE) {
-		dma_addr_t dma = pool->dma + pool->offset;
-		int size = PAGE_SIZE - pool->offset;
-		dma_unmap_single(&bp->pdev->dev, dma, size, DMA_FROM_DEVICE);
-	}
 	put_page(pool->page);
 	pool->page = NULL;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c+43−15

 {
 	struct bnx2x *bp = netdev_priv(dev);
 	int cfg_idx = bnx2x_get_link_cfg_idx(bp);
+	u32 media_type;
 	/* Dual Media boards present all available port types */
 	cmd->supported = bp->port.supported[cfg_idx] |
 		(bp->port.supported[cfg_idx ^ 1] &
 		 (SUPPORTED_TP | SUPPORTED_FIBRE));
 	cmd->advertising = bp->port.advertising[cfg_idx];
-	if (bp->link_params.phy[bnx2x_get_cur_phy_idx(bp)].media_type ==
+	media_type = bp->link_params.phy[bnx2x_get_cur_phy_idx(bp)].media_type;
-	    ETH_PHY_SFP_1G_FIBER) {
+	if (media_type == ETH_PHY_SFP_1G_FIBER) {
 		cmd->supported &= ~(SUPPORTED_10000baseT_Full);
 		cmd->advertising &= ~(ADVERTISED_10000baseT_Full);
 	}
 			cmd->lp_advertising |= ADVERTISED_100baseT_Full;
 		if (status & LINK_STATUS_LINK_PARTNER_1000THD_CAPABLE)
 			cmd->lp_advertising |= ADVERTISED_1000baseT_Half;
-		if (status & LINK_STATUS_LINK_PARTNER_1000TFD_CAPABLE)
+		if (status & LINK_STATUS_LINK_PARTNER_1000TFD_CAPABLE) {
-			cmd->lp_advertising |= ADVERTISED_1000baseT_Full;
+			if (media_type == ETH_PHY_KR) {
+				cmd->lp_advertising |=
+					ADVERTISED_1000baseKX_Full;
+			} else {
+				cmd->lp_advertising |=
+					ADVERTISED_1000baseT_Full;
+			}
+		}
 		if (status & LINK_STATUS_LINK_PARTNER_2500XFD_CAPABLE)
 			cmd->lp_advertising |= ADVERTISED_2500baseX_Full;
-		if (status & LINK_STATUS_LINK_PARTNER_10GXFD_CAPABLE)
+		if (status & LINK_STATUS_LINK_PARTNER_10GXFD_CAPABLE) {
-			cmd->lp_advertising |= ADVERTISED_10000baseT_Full;
+			if (media_type == ETH_PHY_KR) {
+				cmd->lp_advertising |=
+					ADVERTISED_10000baseKR_Full;
+			} else {
+				cmd->lp_advertising |=
+					ADVERTISED_10000baseT_Full;
+			}
+		}
 		if (status & LINK_STATUS_LINK_PARTNER_20GXFD_CAPABLE)
 			cmd->lp_advertising |= ADVERTISED_20000baseKR2_Full;
 	}
 				return -EINVAL;
 			}
-			if (!(bp->port.supported[cfg_idx] &
+			if (bp->port.supported[cfg_idx] &
-			      SUPPORTED_1000baseT_Full)) {
+			     SUPPORTED_1000baseT_Full) {
+				advertising = (ADVERTISED_1000baseT_Full |
+					       ADVERTISED_TP);
+			} else if (bp->port.supported[cfg_idx] &
+				   SUPPORTED_1000baseKX_Full) {
+				advertising = ADVERTISED_1000baseKX_Full;
+			} else {
 				DP(BNX2X_MSG_ETHTOOL,
 				   "1G full not supported\n");
 				return -EINVAL;
 			}
-			advertising = (ADVERTISED_1000baseT_Full |
-				       ADVERTISED_TP);
 			break;
 		case SPEED_2500:
 				return -EINVAL;
 			}
 			phy_idx = bnx2x_get_cur_phy_idx(bp);
-			if (!(bp->port.supported[cfg_idx]
+			if ((bp->port.supported[cfg_idx] &
-			      & SUPPORTED_10000baseT_Full) ||
+			     SUPPORTED_10000baseT_Full) &&
-			    (bp->link_params.phy[phy_idx].media_type ==
+			    (bp->link_params.phy[phy_idx].media_type !=
 			     ETH_PHY_SFP_1G_FIBER)) {
+				advertising = (ADVERTISED_10000baseT_Full |
+					       ADVERTISED_FIBRE);
+			} else if (bp->port.supported[cfg_idx] &
+			       SUPPORTED_10000baseKR_Full) {
+				advertising = (ADVERTISED_10000baseKR_Full |
+					       ADVERTISED_FIBRE);
+			} else {
 				DP(BNX2X_MSG_ETHTOOL,
 				   "10G full not supported\n");
 				return -EINVAL;
 			}
-			advertising = (ADVERTISED_10000baseT_Full |
-				       ADVERTISED_FIBRE);
 			break;
 		default:
 	bp->link_params.multi_phy_config = new_multi_phy_config;
 	if (netif_running(dev)) {
 		bnx2x_stats_handle(bp, STATS_EVENT_STOP);
+		bnx2x_force_link_reset(bp);
 		bnx2x_link_set(bp);
 	}
 	if (!(val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port))) {
 		DP(BNX2X_MSG_ETHTOOL | BNX2X_MSG_NVM,
 		   "cannot get access to nvram interface\n");
+		bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_NVRAM);
 		return -EBUSY;
 	}
 	if (netif_running(dev)) {
 		bnx2x_stats_handle(bp, STATS_EVENT_STOP);
+		bnx2x_force_link_reset(bp);
 		bnx2x_link_set(bp);
 	}

drivers/net/ethernet/broadcom/bnx2x/bnx2x_link.c+32−11

 	case BNX2X_FLOW_CTRL_AUTO:
 		switch (params->req_fc_auto_adv) {
 		case BNX2X_FLOW_CTRL_BOTH:
+		case BNX2X_FLOW_CTRL_RX:
 			*ieee_fc |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
 			break;
-		case BNX2X_FLOW_CTRL_RX:
 		case BNX2X_FLOW_CTRL_TX:
 			*ieee_fc |=
 				MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC;
 	bnx2x_cl45_write(bp, phy, MDIO_AN_DEVAD, MDIO_AN_REG_ADV_PAUSE, val);
 }
-static void bnx2x_pause_resolve(struct link_vars *vars, u32 pause_result)
+static void bnx2x_pause_resolve(struct bnx2x_phy *phy,
-{						/*  LD	    LP	 */
+				struct link_params *params,
+				struct link_vars *vars,
+				u32 pause_result)
+{
+	struct bnx2x *bp = params->bp;
+						/*  LD	    LP	 */
 	switch (pause_result) {			/* ASYM P ASYM P */
 	case 0xb:				/*   1  0   1  1 */
+		DP(NETIF_MSG_LINK, "Flow Control: TX only\n");
 		vars->flow_ctrl = BNX2X_FLOW_CTRL_TX;
 		break;
 	case 0xe:				/*   1  1   1  0 */
+		DP(NETIF_MSG_LINK, "Flow Control: RX only\n");
 		vars->flow_ctrl = BNX2X_FLOW_CTRL_RX;
 		break;
 	case 0x7:				/*   0  1   1  1 */
 	case 0xd:				/*   1  1   0  1 */
 	case 0xf:				/*   1  1   1  1 */
-		vars->flow_ctrl = BNX2X_FLOW_CTRL_BOTH;
+		/* If the user selected to advertise RX ONLY,
+		 * although we advertised both, need to enable
+		 * RX only.
+		 */
+		if (params->req_fc_auto_adv == BNX2X_FLOW_CTRL_BOTH) {
+			DP(NETIF_MSG_LINK, "Flow Control: RX & TX\n");
+			vars->flow_ctrl = BNX2X_FLOW_CTRL_BOTH;
+		} else {
+			DP(NETIF_MSG_LINK, "Flow Control: RX only\n");
+			vars->flow_ctrl = BNX2X_FLOW_CTRL_RX;
+		}
 		break;
 	default:
+		DP(NETIF_MSG_LINK, "Flow Control: None\n");
+		vars->flow_ctrl = BNX2X_FLOW_CTRL_NONE;
 		break;
 	}
 	if (pause_result & (1<<0))
 	pause_result |= (lp_pause &
 			 MDIO_AN_REG_ADV_PAUSE_MASK) >> 10;
 	DP(NETIF_MSG_LINK, "Ext PHY pause result 0x%x\n", pause_result);
-	bnx2x_pause_resolve(vars, pause_result);
+	bnx2x_pause_resolve(phy, params, vars, pause_result);
 }
 				 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK)>>7;
 		DP(NETIF_MSG_LINK, "pause_result CL37 0x%x\n", pause_result);
 	}
-	bnx2x_pause_resolve(vars, pause_result);
+	bnx2x_pause_resolve(phy, params, vars, pause_result);
 }
 		pause_result |= (lp_pause &
 				 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) >> 7;
-		bnx2x_pause_resolve(vars, pause_result);
+		bnx2x_pause_resolve(phy, params, vars, pause_result);
 		DP(NETIF_MSG_LINK, "Ext PHY CL37 pause result 0x%x\n",
 			   pause_result);
 	}
 			   SUPPORTED_100baseT_Half |
 			   SUPPORTED_100baseT_Full |
 			   SUPPORTED_1000baseT_Full |
+			   SUPPORTED_1000baseKX_Full |
 			   SUPPORTED_10000baseT_Full |
+			   SUPPORTED_10000baseKR_Full |
 			   SUPPORTED_20000baseKR2_Full |
 			   SUPPORTED_20000baseMLD2_Full |
 			   SUPPORTED_FIBRE |
 			break;
 		case PORT_HW_CFG_NET_SERDES_IF_KR:
 			phy->media_type = ETH_PHY_KR;
-			phy->supported &= (SUPPORTED_1000baseT_Full |
+			phy->supported &= (SUPPORTED_1000baseKX_Full |
-					   SUPPORTED_10000baseT_Full |
+					   SUPPORTED_10000baseKR_Full |
 					   SUPPORTED_FIBRE |
 					   SUPPORTED_Autoneg |
 					   SUPPORTED_Pause |
 			phy->media_type = ETH_PHY_KR;
 			phy->flags |= FLAGS_WC_DUAL_MODE;
 			phy->supported &= (SUPPORTED_20000baseKR2_Full |
-					   SUPPORTED_10000baseT_Full |
+					   SUPPORTED_10000baseKR_Full |
-					   SUPPORTED_1000baseT_Full |
+					   SUPPORTED_1000baseKX_Full |
 					   SUPPORTED_Autoneg |
 					   SUPPORTED_FIBRE |
 					   SUPPORTED_Pause |

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c+41−19

 void bnx2x_calc_fc_adv(struct bnx2x *bp)
 {
 	u8 cfg_idx = bnx2x_get_link_cfg_idx(bp);
+	bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
+					   ADVERTISED_Pause);
 	switch (bp->link_vars.ieee_fc &
 		MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
-	case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
-		bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
-						   ADVERTISED_Pause);
-		break;
 	case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH:
 		bp->port.advertising[cfg_idx] |= (ADVERTISED_Asym_Pause |
 						  ADVERTISED_Pause);
 		break;
 	default:
-		bp->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
-						   ADVERTISED_Pause);
 		break;
 	}
 }
 		if (load_mode == LOAD_DIAG) {
 			struct link_params *lp = &bp->link_params;
 			lp->loopback_mode = LOOPBACK_XGXS;
-			/* do PHY loopback at 10G speed, if possible */
+			/* Prefer doing PHY loopback at highest speed */
-			if (lp->req_line_speed[cfx_idx] < SPEED_10000) {
+			if (lp->req_line_speed[cfx_idx] < SPEED_20000) {
 				if (lp->speed_cap_mask[cfx_idx] &
-				    PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)
+				    PORT_HW_CFG_SPEED_CAPABILITY_D0_20G)
 					lp->req_line_speed[cfx_idx] =
-					SPEED_10000;
+					SPEED_20000;
+				else if (lp->speed_cap_mask[cfx_idx] &
+					    PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)
+						lp->req_line_speed[cfx_idx] =
+						SPEED_10000;
 				else
 					lp->req_line_speed[cfx_idx] =
 					SPEED_1000;
 				res = true;
 				break;
 			case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_SCPAD_PARITY:
-				if (print)
+				(*par_num)++;
-					_print_next_block((*par_num)++,
-							  "MCP SCPAD");
 				/* clear latched SCPAD PATIRY from MCP */
 				REG_WR(bp, MISC_REG_AEU_CLR_LATCH_SIGNAL,
 				       1UL << 10);
 	    (sig[3] & HW_PRTY_ASSERT_SET_3) ||
 	    (sig[4] & HW_PRTY_ASSERT_SET_4)) {
 		int par_num = 0;
 		DP(NETIF_MSG_HW, "Was parity error: HW block parity attention:\n"
 				 "[0]:0x%08x [1]:0x%08x [2]:0x%08x [3]:0x%08x [4]:0x%08x\n",
 			  sig[0] & HW_PRTY_ASSERT_SET_0,
 			  sig[2] & HW_PRTY_ASSERT_SET_2,
 			  sig[3] & HW_PRTY_ASSERT_SET_3,
 			  sig[4] & HW_PRTY_ASSERT_SET_4);
-		if (print)
+		if (print) {
-			netdev_err(bp->dev,
+			if (((sig[0] & HW_PRTY_ASSERT_SET_0) ||
-				   "Parity errors detected in blocks: ");
+			     (sig[1] & HW_PRTY_ASSERT_SET_1) ||
+			     (sig[2] & HW_PRTY_ASSERT_SET_2) ||
+			     (sig[4] & HW_PRTY_ASSERT_SET_4)) ||
+			     (sig[3] & HW_PRTY_ASSERT_SET_3_WITHOUT_SCPAD)) {
+				netdev_err(bp->dev,
+					   "Parity errors detected in blocks: ");
+			} else {
+				print = false;
+			}
+		}
 		res |= bnx2x_check_blocks_with_parity0(bp,
 			sig[0] & HW_PRTY_ASSERT_SET_0, &par_num, print);
 		res |= bnx2x_check_blocks_with_parity1(bp,
 					 BNX2X_ETH_MAC, &ramrod_flags);
 	} else { /* vf */
 		return bnx2x_vfpf_config_mac(bp, bp->dev->dev_addr,
-					     bp->fp->index, true);
+					     bp->fp->index, set);
 	}
 }
 	 * function stop ramrod is sent, since as part of this ramrod FW access
 	 * PTP registers.
 	 */
-	bnx2x_stop_ptp(bp);
+	if (bp->flags & PTP_SUPPORTED)
+		bnx2x_stop_ptp(bp);
 	/* Disable HW interrupts, NAPI */
 	bnx2x_netif_stop(bp, 1);
 				bp->port.advertising[idx] |=
 					(ADVERTISED_1000baseT_Full |
 					 ADVERTISED_TP);
+			} else if (bp->port.supported[idx] &
+				   SUPPORTED_1000baseKX_Full) {
+				bp->link_params.req_line_speed[idx] =
+					SPEED_1000;
+				bp->port.advertising[idx] |=
+					ADVERTISED_1000baseKX_Full;
 			} else {
 				BNX2X_ERR("NVRAM config error. Invalid link_config 0x%x  speed_cap_mask 0x%x\n",
 				    link_config,
 				bp->port.advertising[idx] |=
 					(ADVERTISED_10000baseT_Full |
 						ADVERTISED_FIBRE);
+			} else if (bp->port.supported[idx] &
+				   SUPPORTED_10000baseKR_Full) {
+				bp->link_params.req_line_speed[idx] =
+					SPEED_10000;
+				bp->port.advertising[idx] |=
+					(ADVERTISED_10000baseKR_Full |
+						ADVERTISED_FIBRE);
 			} else {
 				BNX2X_ERR("NVRAM config error. Invalid link_config 0x%x  speed_cap_mask 0x%x\n",
 				    link_config,

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c+1−1

@@ -424,7 +424,7 @@ static void __bnx2x_vlan_mac_h_exec_pending(struct bnx2x *bp, · 423 unmodified lines
424	o->head_exe_request = false;	424	o->head_exe_request = false;
425	o->saved_ramrod_flags = 0;	425	o->saved_ramrod_flags = 0;
426	rc = bnx2x_exe_queue_step(bp, &o->exe_queue, &ramrod_flags);	426	rc = bnx2x_exe_queue_step(bp, &o->exe_queue, &ramrod_flags);
427	if (rc != 0) {	427	if ((rc != 0) && (rc != 1)) {
428	BNX2X_ERR("execution of pending commands failed with rc %d\n",	428	BNX2X_ERR("execution of pending commands failed with rc %d\n",
429	rc);	429	rc);
430	#ifdef BNX2X_STOP_ON_ERROR	430	#ifdef BNX2X_STOP_ON_ERROR

drivers/net/ethernet/broadcom/genet/bcmgenet.h+1−0

@@ -594,6 +594,7 @@ struct bcmgenet_priv { · 593 unmodified lines
594	wait_queue_head_t wq;	594	wait_queue_head_t wq;
595	struct phy_device *phydev;	595	struct phy_device *phydev;
596	struct device_node *phy_dn;	596	struct device_node *phy_dn;
		597	struct device_node *mdio_dn;
597	struct mii_bus *mii_bus;	598	struct mii_bus *mii_bus;
598	u16 gphy_rev;	599	u16 gphy_rev;
599	struct clk *clk_eee;	600	struct clk *clk_eee;

drivers/net/ethernet/broadcom/genet/bcmmii.c+50−4

@@ -408,6 +408,52 @@ static int bcmgenet_mii_probe(struct net_device *dev) · 407 unmodified lines
408	return 0;	408	return 0;
409	}	409	}
410		410
		411	/* Workaround for integrated BCM7xxx Gigabit PHYs which have a problem with
		412	* their internal MDIO management controller making them fail to successfully
		413	* be read from or written to for the first transaction. We insert a dummy
		414	* BMSR read here to make sure that phy_get_device() and get_phy_id() can
		415	* correctly read the PHY MII_PHYSID1/2 registers and successfully register a
		416	* PHY device for this peripheral.
		417	*
		418	* Once the PHY driver is registered, we can workaround subsequent reads from
		419	* there (e.g: during system-wide power management).
		420	*
		421	* bus->reset is invoked before mdiobus_scan during mdiobus_register and is
		422	* therefore the right location to stick that workaround. Since we do not want
		423	* to read from non-existing PHYs, we either use bus->phy_mask or do a manual
		424	* Device Tree scan to limit the search area.
		425	*/
		426	static int bcmgenet_mii_bus_reset(struct mii_bus *bus)
		427	{
		428	struct net_device *dev = bus->priv;
		429	struct bcmgenet_priv *priv = netdev_priv(dev);
		430	struct device_node *np = priv->mdio_dn;
		431	struct device_node *child = NULL;
		432	u32 read_mask = 0;
		433	int addr = 0;
		434
		435	if (!np) {
		436	read_mask = 1 << priv->phy_addr;
		437	} else {
		438	for_each_available_child_of_node(np, child) {
		439	addr = of_mdio_parse_addr(&dev->dev, child);
		440	if (addr < 0)
		441	continue;
		442
		443	read_mask \|= 1 << addr;
		444	}
		445	}
		446
		447	for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
		448	if (read_mask & 1 << addr) {
		449	dev_dbg(&dev->dev, "Workaround for PHY @ %d\n", addr);
		450	mdiobus_read(bus, addr, MII_BMSR);
		451	}
		452	}
		453
		454	return 0;
		455	}
		456
411	static int bcmgenet_mii_alloc(struct bcmgenet_priv *priv)	457	static int bcmgenet_mii_alloc(struct bcmgenet_priv *priv)
412	{	458	{
413	struct mii_bus *bus;	459	struct mii_bus *bus;
@@ -427,6 +473,7 @@ static int bcmgenet_mii_alloc(struct bcmgenet_priv *priv) · 13 unmodified lines
427	bus->parent = &priv->pdev->dev;	473	bus->parent = &priv->pdev->dev;
428	bus->read = bcmgenet_mii_read;	474	bus->read = bcmgenet_mii_read;
429	bus->write = bcmgenet_mii_write;	475	bus->write = bcmgenet_mii_write;
		476	bus->reset = bcmgenet_mii_bus_reset;
430	snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d",	477	snprintf(bus->id, MII_BUS_ID_SIZE, "%s-%d",
431	priv->pdev->name, priv->pdev->id);	478	priv->pdev->name, priv->pdev->id);
432		479
@@ -443,7 +490,6 @@ static int bcmgenet_mii_of_init(struct bcmgenet_priv *priv) · 10 unmodified lines
443	{	490	{
444	struct device_node *dn = priv->pdev->dev.of_node;	491	struct device_node *dn = priv->pdev->dev.of_node;
445	struct device *kdev = &priv->pdev->dev;	492	struct device *kdev = &priv->pdev->dev;
446	struct device_node *mdio_dn;
447	char *compat;	493	char *compat;
448	int ret;	494	int ret;
449		495
@@ -451,14 +497,14 @@ static int bcmgenet_mii_of_init(struct bcmgenet_priv *priv) · 1 unmodified line
451	if (!compat)	497	if (!compat)
452	return -ENOMEM;	498	return -ENOMEM;
453		499
454	mdio_dn = of_find_compatible_node(dn, NULL, compat);	500	priv->mdio_dn = of_find_compatible_node(dn, NULL, compat);
455	kfree(compat);	501	kfree(compat);
456	if (!mdio_dn) {	502	if (!priv->mdio_dn) {
457	dev_err(kdev, "unable to find MDIO bus node\n");	503	dev_err(kdev, "unable to find MDIO bus node\n");
458	return -ENODEV;	504	return -ENODEV;
459	}	505	}
460		506
461	ret = of_mdiobus_register(priv->mii_bus, mdio_dn);	507	ret = of_mdiobus_register(priv->mii_bus, priv->mdio_dn);
462	if (ret) {	508	if (ret) {
463	dev_err(kdev, "failed to register MDIO bus\n");	509	dev_err(kdev, "failed to register MDIO bus\n");
464	return ret;	510	return ret;

drivers/net/ethernet/cavium/liquidio/lio_ethtool.c+3−2

@@ -434,8 +434,9 @@ static int lio_set_phys_id(struct net_device *netdev, · 433 unmodified lines
434	if (ret)	434	if (ret)
435	return ret;	435	return ret;
436		436
437	octnet_mdio45_access(lio, 1, LIO68XX_LED_BEACON_ADDR,	437	ret = octnet_mdio45_access(lio, 1,
438	&lio->phy_beacon_val);	438	LIO68XX_LED_BEACON_ADDR,
		439	&lio->phy_beacon_val);
439	if (ret)	440	if (ret)
440	return ret;	441	return ret;
441		442

drivers/net/ethernet/cavium/liquidio/octeon_device.c+3−8

@@ -650,14 +650,12 @@ void octeon_free_device_mem(struct octeon_device *oct) · 649 unmodified lines
650		650
651	for (i = 0; i < MAX_OCTEON_OUTPUT_QUEUES; i++) {	651	for (i = 0; i < MAX_OCTEON_OUTPUT_QUEUES; i++) {
652	/* could check mask as well */	652	/* could check mask as well */
653	if (oct->droq[i])	653	vfree(oct->droq[i]);
654	vfree(oct->droq[i]);
655	}	654	}
656		655
657	for (i = 0; i < MAX_OCTEON_INSTR_QUEUES; i++) {	656	for (i = 0; i < MAX_OCTEON_INSTR_QUEUES; i++) {
658	/* could check mask as well */	657	/* could check mask as well */
659	if (oct->instr_queue[i])	658	vfree(oct->instr_queue[i]);
660	vfree(oct->instr_queue[i]);
661	}	659	}
662		660
663	i = oct->octeon_id;	661	i = oct->octeon_id;
@@ -1078,10 +1076,7 @@ octeon_unregister_dispatch_fn(struct octeon_device *oct, u16 opcode, · 414 unmodified lines
1078	oct->dispatch.count--;	1076	oct->dispatch.count--;
1079		1077
1080	spin_unlock_bh(&oct->dispatch.lock);	1078	spin_unlock_bh(&oct->dispatch.lock);
1081		1079	vfree(dfree);
1082	if (dfree)
1083	vfree(dfree);
1084
1085	return retval;	1080	return retval;
1086	}	1081	}
1087		1082

drivers/net/ethernet/cavium/liquidio/octeon_droq.c+1−3

@@ -216,9 +216,7 @@ int octeon_delete_droq(struct octeon_device *oct, u32 q_no) · 215 unmodified lines
216	dev_dbg(&oct->pci_dev->dev, "%s[%d]\n", __func__, q_no);	216	dev_dbg(&oct->pci_dev->dev, "%s[%d]\n", __func__, q_no);
217		217
218	octeon_droq_destroy_ring_buffers(oct, droq);	218	octeon_droq_destroy_ring_buffers(oct, droq);
219		219	vfree(droq->recv_buf_list);
220	if (droq->recv_buf_list)
221	vfree(droq->recv_buf_list);
222		220
223	if (droq->info_base_addr)	221	if (droq->info_base_addr)
224	cnnic_free_aligned_dma(oct->pci_dev, droq->info_list,	222	cnnic_free_aligned_dma(oct->pci_dev, droq->info_list,

drivers/net/ethernet/cavium/liquidio/request_manager.c+1−2

@@ -175,8 +175,7 @@ int octeon_delete_instr_queue(struct octeon_device *oct, u32 iq_no) · 174 unmodified lines
175	desc_size =	175	desc_size =
176	CFG_GET_IQ_INSTR_TYPE(CHIP_FIELD(oct, cn6xxx, conf));	176	CFG_GET_IQ_INSTR_TYPE(CHIP_FIELD(oct, cn6xxx, conf));
177		177
178	if (iq->request_list)	178	vfree(iq->request_list);
179	vfree(iq->request_list);
180		179
181	if (iq->base_addr) {	180	if (iq->base_addr) {
182	q_size = iq->max_count * desc_size;	181	q_size = iq->max_count * desc_size;

drivers/net/ethernet/cisco/enic/enic_main.c+2−2

@@ -1208,7 +1208,7 @@ static int enic_poll(struct napi_struct *napi, int budget) · 1207 unmodified lines
1208	napi_complete(napi);	1208	napi_complete(napi);
1209	vnic_intr_unmask(&enic->intr[intr]);	1209	vnic_intr_unmask(&enic->intr[intr]);
1210	}	1210	}
1211	enic_poll_unlock_napi(&enic->rq[cq_rq]);	1211	enic_poll_unlock_napi(&enic->rq[cq_rq], napi);
1212		1212
1213	return rq_work_done;	1213	return rq_work_done;
1214	}	1214	}
@@ -1414,7 +1414,7 @@ static int enic_poll_msix_rq(struct napi_struct *napi, int budget) · 199 unmodified lines
1414	*/	1414	*/
1415	enic_calc_int_moderation(enic, &enic->rq[rq]);	1415	enic_calc_int_moderation(enic, &enic->rq[rq]);
1416		1416
1417	enic_poll_unlock_napi(&enic->rq[rq]);	1417	enic_poll_unlock_napi(&enic->rq[rq], napi);
1418	if (work_done < work_to_do) {	1418	if (work_done < work_to_do) {
1419		1419
1420	/* Some work done, but not enough to stay in polling,	1420	/* Some work done, but not enough to stay in polling,

drivers/net/ethernet/cisco/enic/vnic_rq.h+27−64

@@ -21,6 +21,7 @@ · 20 unmodified lines
21	#define _VNIC_RQ_H_	21	#define _VNIC_RQ_H_
22		22
23	#include <linux/pci.h>	23	#include <linux/pci.h>
		24	#include <linux/netdevice.h>
24		25
25	#include "vnic_dev.h"	26	#include "vnic_dev.h"
26	#include "vnic_cq.h"	27	#include "vnic_cq.h"
@@ -75,6 +76,12 @@ struct vnic_rq_buf { · 48 unmodified lines
75	uint64_t wr_id;	76	uint64_t wr_id;
76	};	77	};
77		78
		79	enum enic_poll_state {
		80	ENIC_POLL_STATE_IDLE,
		81	ENIC_POLL_STATE_NAPI,
		82	ENIC_POLL_STATE_POLL
		83	};
		84
78	struct vnic_rq {	85	struct vnic_rq {
79	unsigned int index;	86	unsigned int index;
80	struct vnic_dev *vdev;	87	struct vnic_dev *vdev;
@@ -86,19 +93,7 @@ struct vnic_rq { · 5 unmodified lines
86	void *os_buf_head;	93	void *os_buf_head;
87	unsigned int pkts_outstanding;	94	unsigned int pkts_outstanding;
88	#ifdef CONFIG_NET_RX_BUSY_POLL	95	#ifdef CONFIG_NET_RX_BUSY_POLL
89	#define ENIC_POLL_STATE_IDLE 0	96	atomic_t bpoll_state;
90	#define ENIC_POLL_STATE_NAPI (1 << 0) /* NAPI owns this poll */
91	#define ENIC_POLL_STATE_POLL (1 << 1) /* poll owns this poll */
92	#define ENIC_POLL_STATE_NAPI_YIELD (1 << 2) /* NAPI yielded this poll */
93	#define ENIC_POLL_STATE_POLL_YIELD (1 << 3) /* poll yielded this poll */
94	#define ENIC_POLL_YIELD (ENIC_POLL_STATE_NAPI_YIELD \| \
95	ENIC_POLL_STATE_POLL_YIELD)
96	#define ENIC_POLL_LOCKED (ENIC_POLL_STATE_NAPI \| \
97	ENIC_POLL_STATE_POLL)
98	#define ENIC_POLL_USER_PEND (ENIC_POLL_STATE_POLL \| \
99	ENIC_POLL_STATE_POLL_YIELD)
100	unsigned int bpoll_state;
101	spinlock_t bpoll_lock;
102	#endif /* CONFIG_NET_RX_BUSY_POLL */	97	#endif /* CONFIG_NET_RX_BUSY_POLL */
103	};	98	};
104		99
@@ -215,76 +210,43 @@ static inline int vnic_rq_fill(struct vnic_rq *rq, · 110 unmodified lines
215	#ifdef CONFIG_NET_RX_BUSY_POLL	210	#ifdef CONFIG_NET_RX_BUSY_POLL
216	static inline void enic_busy_poll_init_lock(struct vnic_rq *rq)	211	static inline void enic_busy_poll_init_lock(struct vnic_rq *rq)
217	{	212	{
218	spin_lock_init(&rq->bpoll_lock);	213	atomic_set(&rq->bpoll_state, ENIC_POLL_STATE_IDLE);
219	rq->bpoll_state = ENIC_POLL_STATE_IDLE;
220	}	214	}
221		215
222	static inline bool enic_poll_lock_napi(struct vnic_rq *rq)	216	static inline bool enic_poll_lock_napi(struct vnic_rq *rq)
223	{	217	{
224	bool rc = true;	218	int rc = atomic_cmpxchg(&rq->bpoll_state, ENIC_POLL_STATE_IDLE,
225		219	ENIC_POLL_STATE_NAPI);
226	spin_lock(&rq->bpoll_lock);
227	if (rq->bpoll_state & ENIC_POLL_LOCKED) {
228	WARN_ON(rq->bpoll_state & ENIC_POLL_STATE_NAPI);
229	rq->bpoll_state \|= ENIC_POLL_STATE_NAPI_YIELD;
230	rc = false;
231	} else {
232	rq->bpoll_state = ENIC_POLL_STATE_NAPI;
233	}
234	spin_unlock(&rq->bpoll_lock);
235		220
236	return rc;	221	return (rc == ENIC_POLL_STATE_IDLE);
237	}	222	}
238		223
239	static inline bool enic_poll_unlock_napi(struct vnic_rq *rq)	224	static inline void enic_poll_unlock_napi(struct vnic_rq *rq,
		225	struct napi_struct *napi)
240	{	226	{
241	bool rc = false;	227	WARN_ON(atomic_read(&rq->bpoll_state) != ENIC_POLL_STATE_NAPI);
242		228	napi_gro_flush(napi, false);
243	spin_lock(&rq->bpoll_lock);	229	atomic_set(&rq->bpoll_state, ENIC_POLL_STATE_IDLE);
244	WARN_ON(rq->bpoll_state &
245	(ENIC_POLL_STATE_POLL \| ENIC_POLL_STATE_NAPI_YIELD));
246	if (rq->bpoll_state & ENIC_POLL_STATE_POLL_YIELD)
247	rc = true;
248	rq->bpoll_state = ENIC_POLL_STATE_IDLE;
249	spin_unlock(&rq->bpoll_lock);
250
251	return rc;
252	}	230	}
253		231
254	static inline bool enic_poll_lock_poll(struct vnic_rq *rq)	232	static inline bool enic_poll_lock_poll(struct vnic_rq *rq)
255	{	233	{
256	bool rc = true;	234	int rc = atomic_cmpxchg(&rq->bpoll_state, ENIC_POLL_STATE_IDLE,
257		235	ENIC_POLL_STATE_POLL);
258	spin_lock_bh(&rq->bpoll_lock);
259	if (rq->bpoll_state & ENIC_POLL_LOCKED) {
260	rq->bpoll_state \|= ENIC_POLL_STATE_POLL_YIELD;
261	rc = false;
262	} else {
263	rq->bpoll_state \|= ENIC_POLL_STATE_POLL;
264	}
265	spin_unlock_bh(&rq->bpoll_lock);
266		236
267	return rc;	237	return (rc == ENIC_POLL_STATE_IDLE);
268	}	238	}
269		239
270	static inline bool enic_poll_unlock_poll(struct vnic_rq *rq)
271	{
272	bool rc = false;
273		240
274	spin_lock_bh(&rq->bpoll_lock);	241	static inline void enic_poll_unlock_poll(struct vnic_rq *rq)
275	WARN_ON(rq->bpoll_state & ENIC_POLL_STATE_NAPI);	242	{
276	if (rq->bpoll_state & ENIC_POLL_STATE_POLL_YIELD)	243	WARN_ON(atomic_read(&rq->bpoll_state) != ENIC_POLL_STATE_POLL);
277	rc = true;	244	atomic_set(&rq->bpoll_state, ENIC_POLL_STATE_IDLE);
278	rq->bpoll_state = ENIC_POLL_STATE_IDLE;
279	spin_unlock_bh(&rq->bpoll_lock);
280
281	return rc;
282	}	245	}
283		246
284	static inline bool enic_poll_busy_polling(struct vnic_rq *rq)	247	static inline bool enic_poll_busy_polling(struct vnic_rq *rq)
285	{	248	{
286	WARN_ON(!(rq->bpoll_state & ENIC_POLL_LOCKED));	249	return atomic_read(&rq->bpoll_state) & ENIC_POLL_STATE_POLL;
287	return rq->bpoll_state & ENIC_POLL_USER_PEND;
288	}	250	}
289		251
290	#else	252	#else
@@ -298,7 +260,8 @@ static inline bool enic_poll_lock_napi(struct vnic_rq *rq) · 7 unmodified lines
298	return true;	260	return true;
299	}	261	}
300		262
301	static inline bool enic_poll_unlock_napi(struct vnic_rq *rq)	263	static inline bool enic_poll_unlock_napi(struct vnic_rq *rq,
		264	struct napi_struct *napi)
302	{	265	{
303	return false;	266	return false;
304	}	267	}

drivers/net/ethernet/freescale/Kconfig+2−2

 config GIANFAR
 	tristate "Gianfar Ethernet"
-	depends on FSL_SOC
 	select FSL_PQ_MDIO
 	select PHYLIB
 	select CRC32
 	---help---
 	  This driver supports the Gigabit TSEC on the MPC83xx, MPC85xx,
-	  and MPC86xx family of chips, and the FEC on the 8540.
+	  and MPC86xx family of chips, the eTSEC on LS1021A and the FEC
+	  on the 8540.
 endif # NET_VENDOR_FREESCALE

drivers/net/ethernet/freescale/fec.h+2−0

@@ -428,6 +428,8 @@ struct bufdesc_ex { · 427 unmodified lines
428	#define FEC_QUIRK_BUG_CAPTURE (1 << 10)	428	#define FEC_QUIRK_BUG_CAPTURE (1 << 10)
429	/* Controller has only one MDIO bus */	429	/* Controller has only one MDIO bus */
430	#define FEC_QUIRK_SINGLE_MDIO (1 << 11)	430	#define FEC_QUIRK_SINGLE_MDIO (1 << 11)
		431	/* Controller supports RACC register */
		432	#define FEC_QUIRK_HAS_RACC (1 << 12)
431		433
432	struct fec_enet_priv_tx_q {	434	struct fec_enet_priv_tx_q {
433	int index;	435	int index;

drivers/net/ethernet/freescale/fec_main.c+17−13

 		.driver_data = 0,
 	}, {
 		.name = "imx25-fec",
-		.driver_data = FEC_QUIRK_USE_GASKET,
+		.driver_data = FEC_QUIRK_USE_GASKET | FEC_QUIRK_HAS_RACC,
 	}, {
 		.name = "imx27-fec",
-		.driver_data = 0,
+		.driver_data = FEC_QUIRK_HAS_RACC,
 	}, {
 		.name = "imx28-fec",
 		.driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_SWAP_FRAME |
-				FEC_QUIRK_SINGLE_MDIO,
+				FEC_QUIRK_SINGLE_MDIO | FEC_QUIRK_HAS_RACC,
 	}, {
 		.name = "imx6q-fec",
 		.driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |
 				FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM |
-				FEC_QUIRK_HAS_VLAN | FEC_QUIRK_ERR006358,
+				FEC_QUIRK_HAS_VLAN | FEC_QUIRK_ERR006358 |
+				FEC_QUIRK_HAS_RACC,
 	}, {
 		.name = "mvf600-fec",
-		.driver_data = FEC_QUIRK_ENET_MAC,
+		.driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_RACC,
 	}, {
 		.name = "imx6sx-fec",
 		.driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |
 				FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM |
 				FEC_QUIRK_HAS_VLAN | FEC_QUIRK_HAS_AVB |
-				FEC_QUIRK_ERR007885 | FEC_QUIRK_BUG_CAPTURE,
+				FEC_QUIRK_ERR007885 | FEC_QUIRK_BUG_CAPTURE |
+				FEC_QUIRK_HAS_RACC,
 	}, {
 		/* sentinel */
 	}
 	writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
 #if !defined(CONFIG_M5272)
-	/* set RX checksum */
+	if (fep->quirks & FEC_QUIRK_HAS_RACC) {
-	val = readl(fep->hwp + FEC_RACC);
+		/* set RX checksum */
-	if (fep->csum_flags & FLAG_RX_CSUM_ENABLED)
+		val = readl(fep->hwp + FEC_RACC);
-		val |= FEC_RACC_OPTIONS;
+		if (fep->csum_flags & FLAG_RX_CSUM_ENABLED)
-	else
+			val |= FEC_RACC_OPTIONS;
-		val &= ~FEC_RACC_OPTIONS;
+		else
-	writel(val, fep->hwp + FEC_RACC);
+			val &= ~FEC_RACC_OPTIONS;
+		writel(val, fep->hwp + FEC_RACC);
+	}
 #endif
 	/*

drivers/net/ethernet/icplus/ipg.c+1−1

@@ -1028,7 +1028,7 @@ static struct net_device_stats ipg_nic_get_stats(struct net_device dev) · 1027 unmodified lines
1028		1028
1029	/* detailed rx_errors */	1029	/* detailed rx_errors */
1030	sp->stats.rx_length_errors += ipg_r16(IPG_INRANGELENGTHERRORS) +	1030	sp->stats.rx_length_errors += ipg_r16(IPG_INRANGELENGTHERRORS) +
1031	ipg_r16(IPG_FRAMETOOLONGERRRORS);	1031	ipg_r16(IPG_FRAMETOOLONGERRORS);
1032	sp->stats.rx_crc_errors += ipg_r16(IPG_FRAMECHECKSEQERRORS);	1032	sp->stats.rx_crc_errors += ipg_r16(IPG_FRAMECHECKSEQERRORS);
1033		1033
1034	/* Unutilized IPG statistic registers. */	1034	/* Unutilized IPG statistic registers. */

drivers/net/ethernet/icplus/ipg.h+1−1

@@ -102,7 +102,7 @@ enum ipg_regs { · 101 unmodified lines
102	#define IPG_MCSTFRAMESRCVDOK 0xB8	102	#define IPG_MCSTFRAMESRCVDOK 0xB8
103	#define IPG_BCSTFRAMESRCVDOK 0xBE	103	#define IPG_BCSTFRAMESRCVDOK 0xBE
104	#define IPG_MACCONTROLFRAMESRCVD 0xC6	104	#define IPG_MACCONTROLFRAMESRCVD 0xC6
105	#define IPG_FRAMETOOLONGERRRORS 0xC8	105	#define IPG_FRAMETOOLONGERRORS 0xC8
106	#define IPG_INRANGELENGTHERRORS 0xCA	106	#define IPG_INRANGELENGTHERRORS 0xCA
107	#define IPG_FRAMECHECKSEQERRORS 0xCC	107	#define IPG_FRAMECHECKSEQERRORS 0xCC
108	#define IPG_FRAMESLOSTRXERRORS 0xCE	108	#define IPG_FRAMESLOSTRXERRORS 0xCE

drivers/net/ethernet/intel/e1000e/ich8lan.c+98−28

 	if (ret_val)
 		return false;
 out:
-	if ((hw->mac.type == e1000_pch_lpt) ||
+	if ((hw->mac.type == e1000_pch_lpt) || (hw->mac.type == e1000_pch_spt)) {
-	    (hw->mac.type == e1000_pch_spt)) {
+		/* Only unforce SMBus if ME is not active */
-		/* Unforce SMBus mode in PHY */
+		if (!(er32(FWSM) & E1000_ICH_FWSM_FW_VALID)) {
-		e1e_rphy_locked(hw, CV_SMB_CTRL, &phy_reg);
+			/* Unforce SMBus mode in PHY */
-		phy_reg &= ~CV_SMB_CTRL_FORCE_SMBUS;
+			e1e_rphy_locked(hw, CV_SMB_CTRL, &phy_reg);
-		e1e_wphy_locked(hw, CV_SMB_CTRL, phy_reg);
+			phy_reg &= ~CV_SMB_CTRL_FORCE_SMBUS;
+			e1e_wphy_locked(hw, CV_SMB_CTRL, phy_reg);
-		/* Unforce SMBus mode in MAC */
+			/* Unforce SMBus mode in MAC */
-		mac_reg = er32(CTRL_EXT);
+			mac_reg = er32(CTRL_EXT);
-		mac_reg &= ~E1000_CTRL_EXT_FORCE_SMBUS;
+			mac_reg &= ~E1000_CTRL_EXT_FORCE_SMBUS;
-		ew32(CTRL_EXT, mac_reg);
+			ew32(CTRL_EXT, mac_reg);
+		}
 	}
 	return true;
 	u32 mac_reg;
 	s32 ret_val = 0;
 	u16 phy_reg;
+	u16 oem_reg = 0;
 	if ((hw->mac.type < e1000_pch_lpt) ||
 	    (hw->adapter->pdev->device == E1000_DEV_ID_PCH_LPT_I217_LM) ||
 	if (ret_val)
 		goto out;
+	/* Force SMBus mode in PHY */
+	ret_val = e1000_read_phy_reg_hv_locked(hw, CV_SMB_CTRL, &phy_reg);
+	if (ret_val)
+		goto release;
+	phy_reg |= CV_SMB_CTRL_FORCE_SMBUS;
+	e1000_write_phy_reg_hv_locked(hw, CV_SMB_CTRL, phy_reg);
+	/* Force SMBus mode in MAC */
+	mac_reg = er32(CTRL_EXT);
+	mac_reg |= E1000_CTRL_EXT_FORCE_SMBUS;
+	ew32(CTRL_EXT, mac_reg);
 	/* Si workaround for ULP entry flow on i127/rev6 h/w.  Enable
 	 * LPLU and disable Gig speed when entering ULP
 	 */
 	if ((hw->phy.type == e1000_phy_i217) && (hw->phy.revision == 6)) {
 		ret_val = e1000_read_phy_reg_hv_locked(hw, HV_OEM_BITS,
-						       &phy_reg);
+						       &oem_reg);
 		if (ret_val)
 			goto release;
+		phy_reg = oem_reg;
 		phy_reg |= HV_OEM_BITS_LPLU | HV_OEM_BITS_GBE_DIS;
 		ret_val = e1000_write_phy_reg_hv_locked(hw, HV_OEM_BITS,
 							phy_reg);
 		if (ret_val)
 			goto release;
 	}
-	/* Force SMBus mode in PHY */
-	ret_val = e1000_read_phy_reg_hv_locked(hw, CV_SMB_CTRL, &phy_reg);
-	if (ret_val)
-		goto release;
-	phy_reg |= CV_SMB_CTRL_FORCE_SMBUS;
-	e1000_write_phy_reg_hv_locked(hw, CV_SMB_CTRL, phy_reg);
-	/* Force SMBus mode in MAC */
-	mac_reg = er32(CTRL_EXT);
-	mac_reg |= E1000_CTRL_EXT_FORCE_SMBUS;
-	ew32(CTRL_EXT, mac_reg);
 	/* Set Inband ULP Exit, Reset to SMBus mode and
 	 * Disable SMBus Release on PERST# in PHY
 	 */
 	if (to_sx) {
 		if (er32(WUFC) & E1000_WUFC_LNKC)
 			phy_reg |= I218_ULP_CONFIG1_WOL_HOST;
+		else
+			phy_reg &= ~I218_ULP_CONFIG1_WOL_HOST;
 		phy_reg |= I218_ULP_CONFIG1_STICKY_ULP;
+		phy_reg &= ~I218_ULP_CONFIG1_INBAND_EXIT;
 	} else {
 		phy_reg |= I218_ULP_CONFIG1_INBAND_EXIT;
+		phy_reg &= ~I218_ULP_CONFIG1_STICKY_ULP;
+		phy_reg &= ~I218_ULP_CONFIG1_WOL_HOST;
 	}
 	e1000_write_phy_reg_hv_locked(hw, I218_ULP_CONFIG1, phy_reg);
 	/* Commit ULP changes in PHY by starting auto ULP configuration */
 	phy_reg |= I218_ULP_CONFIG1_START;
 	e1000_write_phy_reg_hv_locked(hw, I218_ULP_CONFIG1, phy_reg);
+	if ((hw->phy.type == e1000_phy_i217) && (hw->phy.revision == 6) &&
+	    to_sx && (er32(STATUS) & E1000_STATUS_LU)) {
+		ret_val = e1000_write_phy_reg_hv_locked(hw, HV_OEM_BITS,
+							oem_reg);
+		if (ret_val)
+			goto release;
+	}
 release:
 	hw->phy.ops.release(hw);
 out:
 	if (((hw->mac.type == e1000_pch2lan) ||
 	     (hw->mac.type == e1000_pch_lpt) ||
 	     (hw->mac.type == e1000_pch_spt)) && link) {
-		u32 reg;
+		u16 speed, duplex;
-		reg = er32(STATUS);
+		e1000e_get_speed_and_duplex_copper(hw, &speed, &duplex);
 		tipg_reg = er32(TIPG);
 		tipg_reg &= ~E1000_TIPG_IPGT_MASK;
-		if (!(reg & (E1000_STATUS_FD | E1000_STATUS_SPEED_MASK))) {
+		if (duplex == HALF_DUPLEX && speed == SPEED_10) {
 			tipg_reg |= 0xFF;
 			/* Reduce Rx latency in analog PHY */
 			emi_val = 0;
+		} else if (hw->mac.type == e1000_pch_spt &&
+			   duplex == FULL_DUPLEX && speed != SPEED_1000) {
+			tipg_reg |= 0xC;
+			emi_val = 1;
 		} else {
 			/* Roll back the default values */
 		if (ret_val)
 			return ret_val;
+		if (hw->mac.type == e1000_pch_spt) {
+			u16 data;
+			u16 ptr_gap;
+			if (speed == SPEED_1000) {
+				ret_val = hw->phy.ops.acquire(hw);
+				if (ret_val)
+					return ret_val;
+				ret_val = e1e_rphy_locked(hw,
+							  PHY_REG(776, 20),
+							  &data);
+				if (ret_val) {
+					hw->phy.ops.release(hw);
+					return ret_val;
+				}
+				ptr_gap = (data & (0x3FF << 2)) >> 2;
+				if (ptr_gap < 0x18) {
+					data &= ~(0x3FF << 2);
+					data |= (0x18 << 2);
+					ret_val =
+					    e1e_wphy_locked(hw,
+							    PHY_REG(776, 20),
+							    data);
+				}
+				hw->phy.ops.release(hw);
+				if (ret_val)
+					return ret_val;
+			}
+		}
+	}
+	/* I217 Packet Loss issue:
+	 * ensure that FEXTNVM4 Beacon Duration is set correctly
+	 * on power up.
+	 * Set the Beacon Duration for I217 to 8 usec
+	 */
+	if ((hw->mac.type == e1000_pch_lpt) || (hw->mac.type == e1000_pch_spt)) {
+		u32 mac_reg;
+		mac_reg = er32(FEXTNVM4);
+		mac_reg &= ~E1000_FEXTNVM4_BEACON_DURATION_MASK;
+		mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_8USEC;
+		ew32(FEXTNVM4, mac_reg);
 	}
 	/* Work-around I218 hang issue */
 	if ((hw->adapter->pdev->device == E1000_DEV_ID_PCH_LPTLP_I218_LM) ||
 	    (hw->adapter->pdev->device == E1000_DEV_ID_PCH_LPTLP_I218_V) ||
 	    (hw->adapter->pdev->device == E1000_DEV_ID_PCH_I218_LM3) ||
-	    (hw->adapter->pdev->device == E1000_DEV_ID_PCH_I218_V3) ||
+	    (hw->adapter->pdev->device == E1000_DEV_ID_PCH_I218_V3)) {
-	    (hw->mac.type == e1000_pch_spt)) {
 		ret_val = e1000_k1_workaround_lpt_lp(hw, link);
 		if (ret_val)
 			return ret_val;

drivers/net/ethernet/intel/e1000e/netdev.c+34−4

 }
 /**
- * e1000e_disable_aspm - Disable ASPM states
+ * __e1000e_disable_aspm - Disable ASPM states
  * @pdev: pointer to PCI device struct
  * @state: bit-mask of ASPM states to disable
+ * @locked: indication if this context holds pci_bus_sem locked.
  *
  * Some devices *must* have certain ASPM states disabled per hardware errata.
  **/
-static void e1000e_disable_aspm(struct pci_dev *pdev, u16 state)
+static void __e1000e_disable_aspm(struct pci_dev *pdev, u16 state, int locked)
 {
 	struct pci_dev *parent = pdev->bus->self;
 	u16 aspm_dis_mask = 0;
 		 "L1" : "");
 #ifdef CONFIG_PCIEASPM
-	pci_disable_link_state_locked(pdev, state);
+	if (locked)
+		pci_disable_link_state_locked(pdev, state);
+	else
+		pci_disable_link_state(pdev, state);
 	/* Double-check ASPM control.  If not disabled by the above, the
 	 * BIOS is preventing that from happening (or CONFIG_PCIEASPM is
 					   aspm_dis_mask);
 }
+/**
+ * e1000e_disable_aspm - Disable ASPM states.
+ * @pdev: pointer to PCI device struct
+ * @state: bit-mask of ASPM states to disable
+ *
+ * This function acquires the pci_bus_sem!
+ * Some devices *must* have certain ASPM states disabled per hardware errata.
+ **/
+static void e1000e_disable_aspm(struct pci_dev *pdev, u16 state)
+{
+	__e1000e_disable_aspm(pdev, state, 0);
+}
+/**
+ * e1000e_disable_aspm_locked   Disable ASPM states.
+ * @pdev: pointer to PCI device struct
+ * @state: bit-mask of ASPM states to disable
+ *
+ * This function must be called with pci_bus_sem acquired!
+ * Some devices *must* have certain ASPM states disabled per hardware errata.
+ **/
+static void e1000e_disable_aspm_locked(struct pci_dev *pdev, u16 state)
+{
+	__e1000e_disable_aspm(pdev, state, 1);
+}
 #ifdef CONFIG_PM
 static int __e1000_resume(struct pci_dev *pdev)
 {
 	if (adapter->flags2 & FLAG2_DISABLE_ASPM_L1)
 		aspm_disable_flag |= PCIE_LINK_STATE_L1;
 	if (aspm_disable_flag)
-		e1000e_disable_aspm(pdev, aspm_disable_flag);
+		e1000e_disable_aspm_locked(pdev, aspm_disable_flag);
 	pci_set_master(pdev);

drivers/net/ethernet/intel/i40evf/i40e_txrx.c+4−0

 	if (!dev)
 		return -ENOMEM;
+	/* warn if we are about to overwrite the pointer */
+	WARN_ON(tx_ring->tx_bi);
 	bi_size = sizeof(struct i40e_tx_buffer) * tx_ring->count;
 	tx_ring->tx_bi = kzalloc(bi_size, GFP_KERNEL);
 	if (!tx_ring->tx_bi)
 	struct device *dev = rx_ring->dev;
 	int bi_size;
+	/* warn if we are about to overwrite the pointer */
+	WARN_ON(rx_ring->rx_bi);
 	bi_size = sizeof(struct i40e_rx_buffer) * rx_ring->count;
 	rx_ring->rx_bi = kzalloc(bi_size, GFP_KERNEL);
 	if (!rx_ring->rx_bi)

drivers/net/ethernet/intel/i40evf/i40evf.h+0−1

@@ -264,7 +264,6 @@ extern const char i40evf_driver_version[]; · 263 unmodified lines
264		264
265	int i40evf_up(struct i40evf_adapter *adapter);	265	int i40evf_up(struct i40evf_adapter *adapter);
266	void i40evf_down(struct i40evf_adapter *adapter);	266	void i40evf_down(struct i40evf_adapter *adapter);
267	void i40evf_reinit_locked(struct i40evf_adapter *adapter);
268	void i40evf_reset(struct i40evf_adapter *adapter);	267	void i40evf_reset(struct i40evf_adapter *adapter);
269	void i40evf_set_ethtool_ops(struct net_device *netdev);	268	void i40evf_set_ethtool_ops(struct net_device *netdev);
270	void i40evf_update_stats(struct i40evf_adapter *adapter);	269	void i40evf_update_stats(struct i40evf_adapter *adapter);

drivers/net/ethernet/intel/i40evf/i40evf_ethtool.c+4−2

 	adapter->tx_desc_count = new_tx_count;
 	adapter->rx_desc_count = new_rx_count;
-	if (netif_running(netdev))
+	if (netif_running(netdev)) {
-		i40evf_reinit_locked(adapter);
+		adapter->flags |= I40EVF_FLAG_RESET_NEEDED;
+		schedule_work(&adapter->reset_task);
+	}
 	return 0;
 }

drivers/net/ethernet/intel/i40evf/i40evf_main.c+47−63

 	struct i40evf_adapter *adapter = netdev_priv(netdev);
 	adapter->tx_timeout_count++;
-	if (!(adapter->flags & I40EVF_FLAG_RESET_PENDING)) {
+	if (!(adapter->flags & (I40EVF_FLAG_RESET_PENDING |
+				I40EVF_FLAG_RESET_NEEDED))) {
 		adapter->flags |= I40EVF_FLAG_RESET_NEEDED;
 		schedule_work(&adapter->reset_task);
 	}
 	for (i = 0; i <= I40E_VFQF_HLUT_MAX_INDEX; i++) {
 		lut = 0;
 		for (j = 0; j < 4; j++) {
-			if (cqueue == adapter->vsi_res->num_queue_pairs)
+			if (cqueue == adapter->num_active_queues)
 				cqueue = 0;
 			lut |= ((cqueue) << (8 * j));
 			cqueue++;
 	i40e_flush(hw);
 }
-#define I40EVF_RESET_WAIT_MS 100
+#define I40EVF_RESET_WAIT_MS 10
-#define I40EVF_RESET_WAIT_COUNT 200
+#define I40EVF_RESET_WAIT_COUNT 500
 /**
  * i40evf_reset_task - Call-back task to handle hardware reset
  * @work: pointer to work_struct
 				&adapter->crit_section))
 		usleep_range(500, 1000);
+	i40evf_misc_irq_disable(adapter);
 	if (adapter->flags & I40EVF_FLAG_RESET_NEEDED) {
-		dev_info(&adapter->pdev->dev, "Requesting reset from PF\n");
+		adapter->flags &= ~I40EVF_FLAG_RESET_NEEDED;
+		/* Restart the AQ here. If we have been reset but didn't
+		 * detect it, or if the PF had to reinit, our AQ will be hosed.
+		 */
+		i40evf_shutdown_adminq(hw);
+		i40evf_init_adminq(hw);
 		i40evf_request_reset(adapter);
 	}
+	adapter->flags |= I40EVF_FLAG_RESET_PENDING;
 	/* poll until we see the reset actually happen */
 	for (i = 0; i < I40EVF_RESET_WAIT_COUNT; i++) {
 		if ((rstat_val != I40E_VFR_VFACTIVE) &&
 		    (rstat_val != I40E_VFR_COMPLETED))
 			break;
-		msleep(I40EVF_RESET_WAIT_MS);
+		usleep_range(500, 1000);
 	}
 	if (i == I40EVF_RESET_WAIT_COUNT) {
-		adapter->flags &= ~I40EVF_FLAG_RESET_PENDING;
+		dev_info(&adapter->pdev->dev, "Never saw reset\n");
 		goto continue_reset; /* act like the reset happened */
 	}
 	for (i = 0; i < I40EVF_RESET_WAIT_COUNT; i++) {
 		rstat_val = rd32(hw, I40E_VFGEN_RSTAT) &
 			    I40E_VFGEN_RSTAT_VFR_STATE_MASK;
-		if ((rstat_val == I40E_VFR_VFACTIVE) ||
+		if (rstat_val == I40E_VFR_VFACTIVE)
-		    (rstat_val == I40E_VFR_COMPLETED))
 			break;
 		msleep(I40EVF_RESET_WAIT_MS);
 	}
+	/* extra wait to make sure minimum wait is met */
+	msleep(I40EVF_RESET_WAIT_MS);
 	if (i == I40EVF_RESET_WAIT_COUNT) {
 		struct i40evf_mac_filter *f, *ftmp;
 		struct i40evf_vlan_filter *fv, *fvtmp;
 		if (netif_running(adapter->netdev)) {
 			set_bit(__I40E_DOWN, &adapter->vsi.state);
-			i40evf_irq_disable(adapter);
-			i40evf_napi_disable_all(adapter);
-			netif_tx_disable(netdev);
-			netif_tx_stop_all_queues(netdev);
 			netif_carrier_off(netdev);
+			netif_tx_disable(netdev);
+			i40evf_napi_disable_all(adapter);
+			i40evf_irq_disable(adapter);
 			i40evf_free_traffic_irqs(adapter);
 			i40evf_free_all_tx_resources(adapter);
 			i40evf_free_all_rx_resources(adapter);
 			list_del(&f->list);
 			kfree(f);
 		}
 		list_for_each_entry_safe(fv, fvtmp, &adapter->vlan_filter_list,
 					 list) {
 			list_del(&fv->list);
 		i40evf_shutdown_adminq(hw);
 		adapter->netdev->flags &= ~IFF_UP;
 		clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section);
+		adapter->flags &= ~I40EVF_FLAG_RESET_PENDING;
+		dev_info(&adapter->pdev->dev, "Reset task did not complete, VF disabled\n");
 		return; /* Do not attempt to reinit. It's dead, Jim. */
 	}
 continue_reset:
-	adapter->flags &= ~I40EVF_FLAG_RESET_PENDING;
-	i40evf_irq_disable(adapter);
 	if (netif_running(adapter->netdev)) {
-		i40evf_napi_disable_all(adapter);
-		netif_tx_disable(netdev);
-		netif_tx_stop_all_queues(netdev);
 		netif_carrier_off(netdev);
+		netif_tx_stop_all_queues(netdev);
+		i40evf_napi_disable_all(adapter);
 	}
+	i40evf_irq_disable(adapter);
 	adapter->state = __I40EVF_RESETTING;
+	adapter->flags &= ~I40EVF_FLAG_RESET_PENDING;
+	/* free the Tx/Rx rings and descriptors, might be better to just
+	 * re-use them sometime in the future
+	 */
+	i40evf_free_all_rx_resources(adapter);
+	i40evf_free_all_tx_resources(adapter);
 	/* kill and reinit the admin queue */
 	if (i40evf_shutdown_adminq(hw))
 	adapter->aq_required = I40EVF_FLAG_AQ_ADD_MAC_FILTER;
 	adapter->aq_required |= I40EVF_FLAG_AQ_ADD_VLAN_FILTER;
 	clear_bit(__I40EVF_IN_CRITICAL_TASK, &adapter->crit_section);
+	i40evf_misc_irq_enable(adapter);
 	mod_timer(&adapter->watchdog_timer, jiffies + 2);
 			goto reset_err;
 		i40evf_irq_enable(adapter, true);
+	} else {
+		adapter->state = __I40EVF_DOWN;
 	}
 	return;
 reset_err:
 	dev_err(&adapter->pdev->dev, "failed to allocate resources during reinit\n");
 			memset(event.msg_buf, 0, I40EVF_MAX_AQ_BUF_SIZE);
 	} while (pending);
+	if ((adapter->flags &
+	     (I40EVF_FLAG_RESET_PENDING | I40EVF_FLAG_RESET_NEEDED)) ||
+	    adapter->state == __I40EVF_RESETTING)
+		goto freedom;
 	/* check for error indications */
 	val = rd32(hw, hw->aq.arq.len);
 	oldval = val;
 	if (oldval != val)
 		wr32(hw, hw->aq.asq.len, val);
+freedom:
 	kfree(event.msg_buf);
 out:
 	/* re-enable Admin queue interrupt cause */
 	return &adapter->net_stats;
 }
-/**
- * i40evf_reinit_locked - Software reinit
- * @adapter: board private structure
- *
- * Reinititalizes the ring structures in response to a software configuration
- * change. Roughly the same as close followed by open, but skips releasing
- * and reallocating the interrupts.
- **/
-void i40evf_reinit_locked(struct i40evf_adapter *adapter)
-{
-	struct net_device *netdev = adapter->netdev;
-	int err;
-	WARN_ON(in_interrupt());
-	i40evf_down(adapter);
-	/* allocate transmit descriptors */
-	err = i40evf_setup_all_tx_resources(adapter);
-	if (err)
-		goto err_reinit;
-	/* allocate receive descriptors */
-	err = i40evf_setup_all_rx_resources(adapter);
-	if (err)
-		goto err_reinit;
-	i40evf_configure(adapter);
-	err = i40evf_up_complete(adapter);
-	if (err)
-		goto err_reinit;
-	i40evf_irq_enable(adapter, true);
-	return;
-err_reinit:
-	dev_err(&adapter->pdev->dev, "failed to allocate resources during reinit\n");
-	i40evf_close(netdev);
-}
 /**
  * i40evf_change_mtu - Change the Maximum Transfer Unit
  * @netdev: network interface device structure
 	if ((new_mtu < 68) || (max_frame > I40E_MAX_RXBUFFER))
 		return -EINVAL;
-	/* must set new MTU before calling down or up */
 	netdev->mtu = new_mtu;
-	i40evf_reinit_locked(adapter);
+	adapter->flags |= I40EVF_FLAG_RESET_NEEDED;
+	schedule_work(&adapter->reset_task);
 	return 0;
 }

drivers/net/ethernet/intel/igb/e1000_82575.c+8−4

 /* Intel(R) Gigabit Ethernet Linux driver
- * Copyright(c) 2007-2014 Intel Corporation.
+ * Copyright(c) 2007-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,
  *  igb_rx_fifo_flush_82575 - Clean rx fifo after RX enable
  *  @hw: pointer to the HW structure
  *
- *  After rx enable if managability is enabled then there is likely some
+ *  After rx enable if manageability is enabled then there is likely some
- *  bad data at the start of the fifo and possibly in the DMA fifo.  This
+ *  bad data at the start of the fifo and possibly in the DMA fifo. This
  *  function clears the fifos and flushes any packets that came in as rx was
  *  being enabled.
  **/
 	u32 rctl, rlpml, rxdctl[4], rfctl, temp_rctl, rx_enabled;
 	int i, ms_wait;
+	/* disable IPv6 options as per hardware errata */
+	rfctl = rd32(E1000_RFCTL);
+	rfctl |= E1000_RFCTL_IPV6_EX_DIS;
+	wr32(E1000_RFCTL, rfctl);
 	if (hw->mac.type != e1000_82575 ||
 	    !(rd32(E1000_MANC) & E1000_MANC_RCV_TCO_EN))
 		return;
 	 * incoming packets are rejected.  Set enable and wait 2ms so that
 	 * any packet that was coming in as RCTL.EN was set is flushed
 	 */
-	rfctl = rd32(E1000_RFCTL);
 	wr32(E1000_RFCTL, rfctl & ~E1000_RFCTL_LEF);
 	rlpml = rd32(E1000_RLPML);

drivers/net/ethernet/intel/igb/e1000_defines.h+2−1

@@ -344,7 +344,8 @@ · 343 unmodified lines
344	#define E1000_RXCSUM_PCSD 0x00002000 /* packet checksum disabled */	344	#define E1000_RXCSUM_PCSD 0x00002000 /* packet checksum disabled */
345		345
346	/* Header split receive */	346	/* Header split receive */
347	#define E1000_RFCTL_LEF 0x00040000	347	#define E1000_RFCTL_IPV6_EX_DIS 0x00010000
		348	#define E1000_RFCTL_LEF 0x00040000
348		349
349	/* Collision related configuration parameters */	350	/* Collision related configuration parameters */
350	#define E1000_COLLISION_THRESHOLD 15	351	#define E1000_COLLISION_THRESHOLD 15

drivers/net/ethernet/intel/igb/igb_main.c+1−1

@@ -58,7 +58,7 @@ · 57 unmodified lines
58		58
59	#define MAJ 5	59	#define MAJ 5
60	#define MIN 2	60	#define MIN 2
61	#define BUILD 15	61	#define BUILD 18
62	#define DRV_VERSION __stringify(MAJ) "." __stringify(MIN) "." \	62	#define DRV_VERSION __stringify(MAJ) "." __stringify(MIN) "." \
63	__stringify(BUILD) "-k"	63	__stringify(BUILD) "-k"
64	char igb_driver_name[] = "igb";	64	char igb_driver_name[] = "igb";

drivers/net/ethernet/marvell/mvneta.c+26−1

 	unsigned int link;
 	unsigned int duplex;
 	unsigned int speed;
+	unsigned int tx_csum_limit;
 	int use_inband_status:1;
 };
 	dev->mtu = mtu;
-	if (!netif_running(dev))
+	if (!netif_running(dev)) {
+		netdev_update_features(dev);
 		return 0;
+	}
 	/* The interface is running, so we have to force a
 	 * reallocation of the queues
 	mvneta_start_dev(pp);
 	mvneta_port_up(pp);
+	netdev_update_features(dev);
 	return 0;
 }
+static netdev_features_t mvneta_fix_features(struct net_device *dev,
+					     netdev_features_t features)
+{
+	struct mvneta_port *pp = netdev_priv(dev);
+	if (pp->tx_csum_limit && dev->mtu > pp->tx_csum_limit) {
+		features &= ~(NETIF_F_IP_CSUM | NETIF_F_TSO);
+		netdev_info(dev,
+			    "Disable IP checksum for MTU greater than %dB\n",
+			    pp->tx_csum_limit);
+	}
+	return features;
+}
 /* Get mac address */
 static void mvneta_get_mac_addr(struct mvneta_port *pp, unsigned char *addr)
 {
 	.ndo_set_rx_mode     = mvneta_set_rx_mode,
 	.ndo_set_mac_address = mvneta_set_mac_addr,
 	.ndo_change_mtu      = mvneta_change_mtu,
+	.ndo_fix_features    = mvneta_fix_features,
 	.ndo_get_stats64     = mvneta_get_stats64,
 	.ndo_do_ioctl        = mvneta_ioctl,
 };
 		}
 	}
+	if (of_device_is_compatible(dn, "marvell,armada-370-neta"))
+		pp->tx_csum_limit = 1600;
 	pp->tx_ring_size = MVNETA_MAX_TXD;
 	pp->rx_ring_size = MVNETA_MAX_RXD;
 static const struct of_device_id mvneta_match[] = {
 	{ .compatible = "marvell,armada-370-neta" },
+	{ .compatible = "marvell,armada-xp-neta" },
 	{ }
 };
 MODULE_DEVICE_TABLE(of, mvneta_match);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c+0−4

 			mlx4_en_destroy_cq(priv, &priv->rx_cq[i]);
 	}
-	if (priv->base_tx_qpn) {
-		mlx4_qp_release_range(priv->mdev->dev, priv->base_tx_qpn, priv->tx_ring_num);
-		priv->base_tx_qpn = 0;
-	}
 }
 int mlx4_en_alloc_resources(struct mlx4_en_priv *priv)

drivers/net/ethernet/mellanox/mlx4/en_rx.c+6−11

 }
 #endif
 static int check_csum(struct mlx4_cqe *cqe, struct sk_buff *skb, void *va,
-		      int hwtstamp_rx_filter)
+		      netdev_features_t dev_features)
 {
 	__wsum hw_checksum = 0;
 	hw_checksum = csum_unfold((__force __sum16)cqe->checksum);
-	if (((struct ethhdr *)va)->h_proto == htons(ETH_P_8021Q) &&
+	if (cqe->vlan_my_qpn & cpu_to_be32(MLX4_CQE_VLAN_PRESENT_MASK) &&
-	    hwtstamp_rx_filter != HWTSTAMP_FILTER_NONE) {
+	    !(dev_features & NETIF_F_HW_VLAN_CTAG_RX)) {
-		/* next protocol non IPv4 or IPv6 */
-		if (((struct vlan_hdr *)hdr)->h_vlan_encapsulated_proto
-		    != htons(ETH_P_IP) &&
-		    ((struct vlan_hdr *)hdr)->h_vlan_encapsulated_proto
-		    != htons(ETH_P_IPV6))
-			return -1;
 		hw_checksum = get_fixed_vlan_csum(hw_checksum, hdr);
 		hdr += sizeof(struct vlan_hdr);
 	}
 			if (ip_summed == CHECKSUM_COMPLETE) {
 				void *va = skb_frag_address(skb_shinfo(gro_skb)->frags);
-				if (check_csum(cqe, gro_skb, va, ring->hwtstamp_rx_filter)) {
+				if (check_csum(cqe, gro_skb, va,
+					       dev->features)) {
 					ip_summed = CHECKSUM_NONE;
 					ring->csum_none++;
 					ring->csum_complete--;
 		}
 		if (ip_summed == CHECKSUM_COMPLETE) {
-			if (check_csum(cqe, skb, skb->data, ring->hwtstamp_rx_filter)) {
+			if (check_csum(cqe, skb, skb->data, dev->features)) {
 				ip_summed = CHECKSUM_NONE;
 				ring->csum_complete--;
 				ring->csum_none++;

drivers/net/ethernet/mellanox/mlx4/en_tx.c+12−8

 	ring->size = size;
 	ring->size_mask = size - 1;
 	ring->stride = stride;
+	ring->full_size = ring->size - HEADROOM - MAX_DESC_TXBBS;
 	tmp = size * sizeof(struct mlx4_en_tx_info);
 	ring->tx_info = kmalloc_node(tmp, GFP_KERNEL | __GFP_NOWARN, node);
 		mlx4_bf_free(mdev->dev, &ring->bf);
 	mlx4_qp_remove(mdev->dev, &ring->qp);
 	mlx4_qp_free(mdev->dev, &ring->qp);
+	mlx4_qp_release_range(priv->mdev->dev, ring->qpn, 1);
 	mlx4_en_unmap_buffer(&ring->wqres.buf);
 	mlx4_free_hwq_res(mdev->dev, &ring->wqres, ring->buf_size);
 	kfree(ring->bounce_buf);
 		       MLX4_QP_STATE_RST, NULL, 0, 0, &ring->qp);
 }
+static inline bool mlx4_en_is_tx_ring_full(struct mlx4_en_tx_ring *ring)
+{
+	return ring->prod - ring->cons > ring->full_size;
+}
 static void mlx4_en_stamp_wqe(struct mlx4_en_priv *priv,
 			      struct mlx4_en_tx_ring *ring, int index,
 			      u8 owner)
 	netdev_tx_completed_queue(ring->tx_queue, packets, bytes);
-	/*
+	/* Wakeup Tx queue if this stopped, and ring is not full.
-	 * Wakeup Tx queue if this stopped, and at least 1 packet
-	 * was completed
 	 */
-	if (netif_tx_queue_stopped(ring->tx_queue) && txbbs_skipped > 0) {
+	if (netif_tx_queue_stopped(ring->tx_queue) &&
+	    !mlx4_en_is_tx_ring_full(ring)) {
 		netif_tx_wake_queue(ring->tx_queue);
 		ring->wake_queue++;
 	}
 	skb_tx_timestamp(skb);
 	/* Check available TXBBs And 2K spare for prefetch */
-	stop_queue = (int)(ring->prod - ring_cons) >
+	stop_queue = mlx4_en_is_tx_ring_full(ring);
-		      ring->size - HEADROOM - MAX_DESC_TXBBS;
 	if (unlikely(stop_queue)) {
 		netif_tx_stop_queue(ring->tx_queue);
 		ring->queue_stopped++;
 		smp_rmb();
 		ring_cons = ACCESS_ONCE(ring->cons);
-		if (unlikely(((int)(ring->prod - ring_cons)) <=
+		if (unlikely(!mlx4_en_is_tx_ring_full(ring))) {
-			     ring->size - HEADROOM - MAX_DESC_TXBBS)) {
 			netif_tx_wake_queue(ring->tx_queue);
 			ring->wake_queue++;
 		}

drivers/net/ethernet/mellanox/mlx4/intf.c+7−1

 	mutex_lock(&intf_mutex);
 	list_add_tail(&intf->list, &intf_list);
-	list_for_each_entry(priv, &dev_list, dev_list)
+	list_for_each_entry(priv, &dev_list, dev_list) {
+		if (mlx4_is_mfunc(&priv->dev) && (intf->flags & MLX4_INTFF_BONDING)) {
+			mlx4_dbg(&priv->dev,
+				 "SRIOV, disabling HA mode for intf proto %d\n", intf->protocol);
+			intf->flags &= ~MLX4_INTFF_BONDING;
+		}
 		mlx4_add_device(intf, priv);
+	}
 	mutex_unlock(&intf_mutex);

drivers/net/ethernet/mellanox/mlx4/mlx4_en.h+1−1

 	u32			size; /* number of TXBBs */
 	u32			size_mask;
 	u16			stride;
+	u32			full_size;
 	u16			cqn;	/* index of port CQ associated with this ring */
 	u32			buf_size;
 	__be32			doorbell_qpn;
 	int vids[128];
 	bool wol;
 	struct device *ddev;
-	int base_tx_qpn;
 	struct hlist_head mac_hash[MLX4_EN_MAC_HASH_SIZE];
 	struct hwtstamp_config hwtstamp_config;
 	u32 counter_index;

drivers/net/ethernet/renesas/ravb_ptp.c+3−1

 	priv->ptp.current_addend = addend;
 	gccr = ravb_read(ndev, GCCR);
-	if (gccr & GCCR_LTI)
+	if (gccr & GCCR_LTI) {
+		spin_unlock_irqrestore(&priv->lock, flags);
 		return -EBUSY;
+	}
 	ravb_write(ndev, addend & GTI_TIV, GTI);
 	ravb_write(ndev, gccr | GCCR_LTI, GCCR);

drivers/net/ethernet/sis/sis900.h+2−2

@@ -56,7 +56,7 @@ enum sis900_configuration_register_bits { · 55 unmodified lines
56	EDB_MASTER_EN = 0x00002000	56	EDB_MASTER_EN = 0x00002000
57	};	57	};
58		58
59	enum sis900_eeprom_access_reigster_bits {	59	enum sis900_eeprom_access_register_bits {
60	MDC = 0x00000040, MDDIR = 0x00000020, MDIO = 0x00000010, /* 7016 specific */	60	MDC = 0x00000040, MDDIR = 0x00000020, MDIO = 0x00000010, /* 7016 specific */
61	EECS = 0x00000008, EECLK = 0x00000004, EEDO = 0x00000002,	61	EECS = 0x00000008, EECLK = 0x00000004, EEDO = 0x00000002,
62	EEDI = 0x00000001	62	EEDI = 0x00000001
@@ -73,7 +73,7 @@ enum sis900_interrupt_register_bits { · 10 unmodified lines
73	RxERR = 0x00000004, RxDESC = 0x00000002, RxOK = 0x00000001	73	RxERR = 0x00000004, RxDESC = 0x00000002, RxOK = 0x00000001
74	};	74	};
75		75
76	enum sis900_interrupt_enable_reigster_bits {	76	enum sis900_interrupt_enable_register_bits {
77	IE = 0x00000001	77	IE = 0x00000001
78	};	78	};
79		79

drivers/net/ethernet/stmicro/stmmac/mmc_core.c+2−2

drivers/net/ethernet/via/Kconfig+2−0

 config VIA_RHINE
 	tristate "VIA Rhine support"
 	depends on (PCI || OF_IRQ)
+	depends on HAS_DMA
 	select CRC32
 	select MII
 	---help---
 config VIA_VELOCITY
 	tristate "VIA Velocity support"
 	depends on (PCI || (OF_ADDRESS && OF_IRQ))
+	depends on HAS_DMA
 	select CRC32
 	select CRC_CCITT
 	select MII

drivers/net/phy/bcm7xxx.c+7−0

@@ -246,6 +246,13 @@ static int bcm7xxx_28nm_config_init(struct phy_device *phydev) · 245 unmodified lines
246	pr_info_once("%s: %s PHY revision: 0x%02x, patch: %d\n",	246	pr_info_once("%s: %s PHY revision: 0x%02x, patch: %d\n",
247	dev_name(&phydev->dev), phydev->drv->name, rev, patch);	247	dev_name(&phydev->dev), phydev->drv->name, rev, patch);
248		248
		249	/* Dummy read to a register to workaround an issue upon reset where the
		250	* internal inverter may not allow the first MDIO transaction to pass
		251	* the MDIO management controller and make us return 0xffff for such
		252	* reads.
		253	*/
		254	phy_read(phydev, MII_BMSR);
		255
249	switch (rev) {	256	switch (rev) {
250	case 0xb0:	257	case 0xb0:
251	ret = bcm7xxx_28nm_b0_afe_config_init(phydev);	258	ret = bcm7xxx_28nm_b0_afe_config_init(phydev);

drivers/net/phy/mdio-bcm-unimac.c+43−0

@@ -120,6 +120,48 @@ static int unimac_mdio_write(struct mii_bus *bus, int phy_id, · 119 unmodified lines
120	return 0;	120	return 0;
121	}	121	}
122		122
		123	/* Workaround for integrated BCM7xxx Gigabit PHYs which have a problem with
		124	* their internal MDIO management controller making them fail to successfully
		125	* be read from or written to for the first transaction. We insert a dummy
		126	* BMSR read here to make sure that phy_get_device() and get_phy_id() can
		127	* correctly read the PHY MII_PHYSID1/2 registers and successfully register a
		128	* PHY device for this peripheral.
		129	*
		130	* Once the PHY driver is registered, we can workaround subsequent reads from
		131	* there (e.g: during system-wide power management).
		132	*
		133	* bus->reset is invoked before mdiobus_scan during mdiobus_register and is
		134	* therefore the right location to stick that workaround. Since we do not want
		135	* to read from non-existing PHYs, we either use bus->phy_mask or do a manual
		136	* Device Tree scan to limit the search area.
		137	*/
		138	static int unimac_mdio_reset(struct mii_bus *bus)
		139	{
		140	struct device_node *np = bus->dev.of_node;
		141	struct device_node *child;
		142	u32 read_mask = 0;
		143	int addr;
		144
		145	if (!np) {
		146	read_mask = ~bus->phy_mask;
		147	} else {
		148	for_each_available_child_of_node(np, child) {
		149	addr = of_mdio_parse_addr(&bus->dev, child);
		150	if (addr < 0)
		151	continue;
		152
		153	read_mask \|= 1 << addr;
		154	}
		155	}
		156
		157	for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
		158	if (read_mask & 1 << addr)
		159	mdiobus_read(bus, addr, MII_BMSR);
		160	}
		161
		162	return 0;
		163	}
		164
123	static int unimac_mdio_probe(struct platform_device *pdev)	165	static int unimac_mdio_probe(struct platform_device *pdev)
124	{	166	{
125	struct unimac_mdio_priv *priv;	167	struct unimac_mdio_priv *priv;
@@ -155,6 +197,7 @@ static int unimac_mdio_probe(struct platform_device *pdev) · 29 unmodified lines
155	bus->parent = &pdev->dev;	197	bus->parent = &pdev->dev;
156	bus->read = unimac_mdio_read;	198	bus->read = unimac_mdio_read;
157	bus->write = unimac_mdio_write;	199	bus->write = unimac_mdio_write;
		200	bus->reset = unimac_mdio_reset;
158	snprintf(bus->id, MII_BUS_ID_SIZE, "%s", pdev->name);	201	snprintf(bus->id, MII_BUS_ID_SIZE, "%s", pdev->name);
159		202
160	bus->irq = kcalloc(PHY_MAX_ADDR, sizeof(int), GFP_KERNEL);	203	bus->irq = kcalloc(PHY_MAX_ADDR, sizeof(int), GFP_KERNEL);

drivers/net/phy/phy_device.c+17−8

 	for (i = 1;
 	     i < num_ids && c45_ids->devices_in_package == 0;
 	     i++) {
-		reg_addr = MII_ADDR_C45 | i << 16 | MDIO_DEVS2;
+retry:		reg_addr = MII_ADDR_C45 | i << 16 | MDIO_DEVS2;
 		phy_reg = mdiobus_read(bus, addr, reg_addr);
 		if (phy_reg < 0)
 			return -EIO;
 			return -EIO;
 		c45_ids->devices_in_package |= (phy_reg & 0xffff);
-		/* If mostly Fs, there is no device there,
-		 * let's get out of here.
-		 */
 		if ((c45_ids->devices_in_package & 0x1fffffff) == 0x1fffffff) {
-			*phy_id = 0xffffffff;
+			if (i) {
-			return 0;
+				/*  If mostly Fs, there is no device there,
+				 *  then let's continue to probe more, as some
+				 *  10G PHYs have zero Devices In package,
+				 *  e.g. Cortina CS4315/CS4340 PHY.
+				 */
+				i = 0;
+				goto retry;
+			} else {
+				/* no device there, let's get out of here */
+				*phy_id = 0xffffffff;
+				return 0;
+			}
 		}
 	}
 	if (phydev->supported & (SUPPORTED_1000baseT_Half |
 				 SUPPORTED_1000baseT_Full)) {
 		adv |= ethtool_adv_to_mii_ctrl1000_t(advertise);
-		if (adv != oldadv)
-			changed = 1;
 	}
+	if (adv != oldadv)
+		changed = 1;
 	err = phy_write(phydev, MII_CTRL1000, adv);
 	if (err < 0)
 		return err;

drivers/net/phy/vitesse.c+14−0

 #define PHY_ID_VSC8244			0x000fc6c0
 #define PHY_ID_VSC8514			0x00070670
 #define PHY_ID_VSC8574			0x000704a0
+#define PHY_ID_VSC8641			0x00070431
 #define PHY_ID_VSC8662			0x00070660
 #define PHY_ID_VSC8221			0x000fc550
 #define PHY_ID_VSC8211			0x000fc4b0
 	.ack_interrupt  = &vsc824x_ack_interrupt,
 	.config_intr    = &vsc82xx_config_intr,
 	.driver         = { .owner = THIS_MODULE,},
+}, {
+	.phy_id         = PHY_ID_VSC8641,
+	.name           = "Vitesse VSC8641",
+	.phy_id_mask    = 0x000ffff0,
+	.features       = PHY_GBIT_FEATURES,
+	.flags          = PHY_HAS_INTERRUPT,
+	.config_init    = &vsc824x_config_init,
+	.config_aneg    = &vsc82x4_config_aneg,
+	.read_status    = &genphy_read_status,
+	.ack_interrupt  = &vsc824x_ack_interrupt,
+	.config_intr    = &vsc82xx_config_intr,
+	.driver         = { .owner = THIS_MODULE,},
 }, {
 	.phy_id         = PHY_ID_VSC8662,
 	.name           = "Vitesse VSC8662",
 	{ PHY_ID_VSC8244, 0x000fffc0 },
 	{ PHY_ID_VSC8514, 0x000ffff0 },
 	{ PHY_ID_VSC8574, 0x000ffff0 },
+	{ PHY_ID_VSC8641, 0x000ffff0 },
 	{ PHY_ID_VSC8662, 0x000ffff0 },
 	{ PHY_ID_VSC8221, 0x000ffff0 },
 	{ PHY_ID_VSC8211, 0x000ffff0 },

drivers/net/vmxnet3/vmxnet3_int.h+2−2

@@ -69,10 +69,10 @@ · 68 unmodified lines
69	/*	69	/*
70	* Version numbers	70	* Version numbers
71	*/	71	*/
72	#define VMXNET3_DRIVER_VERSION_STRING "1.3.5.0-k"	72	#define VMXNET3_DRIVER_VERSION_STRING "1.4.2.0-k"
73		73
74	/* a 32-bit int, each byte encode a verion number in VMXNET3_DRIVER_VERSION */	74	/* a 32-bit int, each byte encode a verion number in VMXNET3_DRIVER_VERSION */
75	#define VMXNET3_DRIVER_VERSION_NUM 0x01030500	75	#define VMXNET3_DRIVER_VERSION_NUM 0x01040200
76		76
77	#if defined(CONFIG_PCI_MSI)	77	#if defined(CONFIG_PCI_MSI)
78	/* RSS only makes sense if MSI-X is supported. */	78	/* RSS only makes sense if MSI-X is supported. */

drivers/net/xen-netfront.c+0−7

 	np                   = netdev_priv(netdev);
 	np->xbdev            = dev;
-	/* No need to use rtnl_lock() before the call below as it
-	 * happens before register_netdev().
-	 */
-	netif_set_real_num_tx_queues(netdev, 0);
 	np->queues = NULL;
 	err = -ENOMEM;
 	xennet_disconnect_backend(info);
 	kfree(info->queues);
 	info->queues = NULL;
-	rtnl_lock();
-	netif_set_real_num_tx_queues(info->netdev, 0);
-	rtnl_unlock();
  out:
 	return err;
 }

include/net/ax25.h+15−1

@@ -13,6 +13,7 @@ · 12 unmodified lines
13	#include <linux/slab.h>	13	#include <linux/slab.h>
14	#include <linux/atomic.h>	14	#include <linux/atomic.h>
15	#include <net/neighbour.h>	15	#include <net/neighbour.h>
		16	#include <net/sock.h>
16		17
17	#define AX25_T1CLAMPLO 1	18	#define AX25_T1CLAMPLO 1
18	#define AX25_T1CLAMPHI (30 * HZ)	19	#define AX25_T1CLAMPHI (30 * HZ)
@@ -246,7 +247,20 @@ typedef struct ax25_cb { · 227 unmodified lines
246	atomic_t refcount;	247	atomic_t refcount;
247	} ax25_cb;	248	} ax25_cb;
248		249
249	#define ax25_sk(__sk) ((ax25_cb *)(__sk)->sk_protinfo)	250	struct ax25_sock {
		251	struct sock sk;
		252	struct ax25_cb *cb;
		253	};
		254
		255	static inline struct ax25_sock ax25_sk(const struct sock sk)
		256	{
		257	return (struct ax25_sock *) sk;
		258	}
		259
		260	static inline struct ax25_cb sk_to_ax25(const struct sock sk)
		261	{
		262	return ax25_sk(sk)->cb;
		263	}
250		264
251	#define ax25_for_each(__ax25, list) \	265	#define ax25_for_each(__ax25, list) \
252	hlist_for_each_entry(__ax25, list, ax25_node)	266	hlist_for_each_entry(__ax25, list, ax25_node)

include/net/sock.h+0−2

   *	@sk_incoming_cpu: record cpu processing incoming packets
   *	@sk_txhash: computed flow hash for use on transmit
   *	@sk_filter: socket filtering instructions
-  *	@sk_protinfo: private area, net family specific, when not using slab
   *	@sk_timer: sock cleanup timer
   *	@sk_stamp: time stamp of last packet received
   *	@sk_tsflags: SO_TIMESTAMPING socket options
 	const struct cred	*sk_peer_cred;
 	long			sk_rcvtimeo;
 	long			sk_sndtimeo;
-	void			*sk_protinfo;
 	struct timer_list	sk_timer;
 	ktime_t			sk_stamp;
 	u16			sk_tsflags;

include/uapi/linux/in.h+13−3

@@ -19,8 +19,10 @@ · 18 unmodified lines
19	#define _UAPI_LINUX_IN_H	19	#define _UAPI_LINUX_IN_H
20		20
21	#include <linux/types.h>	21	#include <linux/types.h>
		22	#include <linux/libc-compat.h>
22	#include <linux/socket.h>	23	#include <linux/socket.h>
23		24
		25	#if __UAPI_DEF_IN_IPPROTO
24	/* Standard well-defined IP protocols. */	26	/* Standard well-defined IP protocols. */
25	enum {	27	enum {
26	IPPROTO_IP = 0, /* Dummy protocol for TCP */	28	IPPROTO_IP = 0, /* Dummy protocol for TCP */
@@ -75,12 +77,14 @@ enum { · 48 unmodified lines
75	#define IPPROTO_RAW IPPROTO_RAW	77	#define IPPROTO_RAW IPPROTO_RAW
76	IPPROTO_MAX	78	IPPROTO_MAX
77	};	79	};
		80	#endif
78		81
79		82	#if __UAPI_DEF_IN_ADDR
80	/* Internet address. */	83	/* Internet address. */
81	struct in_addr {	84	struct in_addr {
82	__be32 s_addr;	85	__be32 s_addr;
83	};	86	};
		87	#endif
84		88
85	#define IP_TOS 1	89	#define IP_TOS 1
86	#define IP_TTL 2	90	#define IP_TTL 2
@@ -158,6 +162,7 @@ struct in_addr { · 71 unmodified lines
158		162
159	/* Request struct for multicast socket ops */	163	/* Request struct for multicast socket ops */
160		164
		165	#if __UAPI_DEF_IP_MREQ
161	struct ip_mreq {	166	struct ip_mreq {
162	struct in_addr imr_multiaddr; /* IP multicast address of group */	167	struct in_addr imr_multiaddr; /* IP multicast address of group */
163	struct in_addr imr_interface; /* local IP address of interface */	168	struct in_addr imr_interface; /* local IP address of interface */
@@ -209,14 +214,18 @@ struct group_filter { · 45 unmodified lines
209	#define GROUP_FILTER_SIZE(numsrc) \	214	#define GROUP_FILTER_SIZE(numsrc) \
210	(sizeof(struct group_filter) - sizeof(struct __kernel_sockaddr_storage) \	215	(sizeof(struct group_filter) - sizeof(struct __kernel_sockaddr_storage) \
211	+ (numsrc) * sizeof(struct __kernel_sockaddr_storage))	216	+ (numsrc) * sizeof(struct __kernel_sockaddr_storage))
		217	#endif
212		218
		219	#if __UAPI_DEF_IN_PKTINFO
213	struct in_pktinfo {	220	struct in_pktinfo {
214	int ipi_ifindex;	221	int ipi_ifindex;
215	struct in_addr ipi_spec_dst;	222	struct in_addr ipi_spec_dst;
216	struct in_addr ipi_addr;	223	struct in_addr ipi_addr;
217	};	224	};
		225	#endif
218		226
219	/* Structure describing an Internet (IP) socket address. */	227	/* Structure describing an Internet (IP) socket address. */
		228	#if __UAPI_DEF_SOCKADDR_IN
220	#define __SOCK_SIZE__ 16 /* sizeof(struct sockaddr) */	229	#define __SOCK_SIZE__ 16 /* sizeof(struct sockaddr) */
221	struct sockaddr_in {	230	struct sockaddr_in {
222	__kernel_sa_family_t sin_family; /* Address family */	231	__kernel_sa_family_t sin_family; /* Address family */
@@ -228,8 +237,9 @@ struct sockaddr_in { · 5 unmodified lines
228	sizeof(unsigned short int) - sizeof(struct in_addr)];	237	sizeof(unsigned short int) - sizeof(struct in_addr)];
229	};	238	};
230	#define sin_zero __pad /* for BSD UNIX comp. -FvK */	239	#define sin_zero __pad /* for BSD UNIX comp. -FvK */
		240	#endif
231		241
232		242	#if __UAPI_DEF_IN_CLASS
233	/*	243	/*
234	* Definitions of the bits in an Internet address integer.	244	* Definitions of the bits in an Internet address integer.
235	* On subnets, host and network parts are found according	245	* On subnets, host and network parts are found according
@@ -280,7 +290,7 @@ struct sockaddr_in { · 44 unmodified lines
280	#define INADDR_ALLHOSTS_GROUP 0xe0000001U /* 224.0.0.1 */	290	#define INADDR_ALLHOSTS_GROUP 0xe0000001U /* 224.0.0.1 */
281	#define INADDR_ALLRTRS_GROUP 0xe0000002U /* 224.0.0.2 */	291	#define INADDR_ALLRTRS_GROUP 0xe0000002U /* 224.0.0.2 */
282	#define INADDR_MAX_LOCAL_GROUP 0xe00000ffU /* 224.0.0.255 */	292	#define INADDR_MAX_LOCAL_GROUP 0xe00000ffU /* 224.0.0.255 */
283		293	#endif
284		294
285	/* <asm/byteorder.h> contains the htonl type stuff.. */	295	/* <asm/byteorder.h> contains the htonl type stuff.. */
286	#include <asm/byteorder.h>	296	#include <asm/byteorder.h>

include/uapi/linux/libc-compat.h+22−0

@@ -56,6 +56,13 @@ · 55 unmodified lines
56		56
57	/* GLIBC headers included first so don't define anything	57	/* GLIBC headers included first so don't define anything
58	* that would already be defined. */	58	* that would already be defined. */
		59	#define __UAPI_DEF_IN_ADDR 0
		60	#define __UAPI_DEF_IN_IPPROTO 0
		61	#define __UAPI_DEF_IN_PKTINFO 0
		62	#define __UAPI_DEF_IP_MREQ 0
		63	#define __UAPI_DEF_SOCKADDR_IN 0
		64	#define __UAPI_DEF_IN_CLASS 0
		65
59	#define __UAPI_DEF_IN6_ADDR 0	66	#define __UAPI_DEF_IN6_ADDR 0
60	/* The exception is the in6_addr macros which must be defined	67	/* The exception is the in6_addr macros which must be defined
61	* if the glibc code didn't define them. This guard matches	68	* if the glibc code didn't define them. This guard matches
@@ -78,6 +85,13 @@ · 16 unmodified lines
78	/* Linux headers included first, and we must define everything	85	/* Linux headers included first, and we must define everything
79	* we need. The expectation is that glibc will check the	86	* we need. The expectation is that glibc will check the
80	* __UAPI_DEF_* defines and adjust appropriately. */	87	* __UAPI_DEF_* defines and adjust appropriately. */
		88	#define __UAPI_DEF_IN_ADDR 1
		89	#define __UAPI_DEF_IN_IPPROTO 1
		90	#define __UAPI_DEF_IN_PKTINFO 1
		91	#define __UAPI_DEF_IP_MREQ 1
		92	#define __UAPI_DEF_SOCKADDR_IN 1
		93	#define __UAPI_DEF_IN_CLASS 1
		94
81	#define __UAPI_DEF_IN6_ADDR 1	95	#define __UAPI_DEF_IN6_ADDR 1
82	/* We unconditionally define the in6_addr macros and glibc must	96	/* We unconditionally define the in6_addr macros and glibc must
83	* coordinate. */	97	* coordinate. */
@@ -103,6 +117,14 @@ · 19 unmodified lines
103	* that we need. */	117	* that we need. */
104	#else /* !defined(__GLIBC__) */	118	#else /* !defined(__GLIBC__) */
105		119
		120	/* Definitions for in.h */
		121	#define __UAPI_DEF_IN_ADDR 1
		122	#define __UAPI_DEF_IN_IPPROTO 1
		123	#define __UAPI_DEF_IN_PKTINFO 1
		124	#define __UAPI_DEF_IP_MREQ 1
		125	#define __UAPI_DEF_SOCKADDR_IN 1
		126	#define __UAPI_DEF_IN_CLASS 1
		127
106	/* Definitions for in6.h */	128	/* Definitions for in6.h */
107	#define __UAPI_DEF_IN6_ADDR 1	129	#define __UAPI_DEF_IN6_ADDR 1
108	#define __UAPI_DEF_IN6_ADDR_ALT 1	130	#define __UAPI_DEF_IN6_ADDR_ALT 1

net/ax25/af_ax25.c+15−15

@@ -57,7 +57,7 @@ static const struct proto_ops ax25_proto_ops; · 56 unmodified lines
57		57
58	static void ax25_free_sock(struct sock *sk)	58	static void ax25_free_sock(struct sock *sk)
59	{	59	{
60	ax25_cb_put(ax25_sk(sk));	60	ax25_cb_put(sk_to_ax25(sk));
61	}	61	}
62		62
63	/*	63	/*
@@ -306,7 +306,7 @@ void ax25_destroy_socket(ax25_cb *ax25) · 242 unmodified lines
306	while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {	306	while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
307	if (skb->sk != ax25->sk) {	307	if (skb->sk != ax25->sk) {
308	/* A pending connection */	308	/* A pending connection */
309	ax25_cb *sax25 = ax25_sk(skb->sk);	309	ax25_cb *sax25 = sk_to_ax25(skb->sk);
310		310
311	/* Queue the unaccepted socket for death */	311	/* Queue the unaccepted socket for death */
312	sock_orphan(skb->sk);	312	sock_orphan(skb->sk);
@@ -551,7 +551,7 @@ static int ax25_setsockopt(struct socket *sock, int level, int optname, · 238 unmodified lines
551	return -EFAULT;	551	return -EFAULT;
552		552
553	lock_sock(sk);	553	lock_sock(sk);
554	ax25 = ax25_sk(sk);	554	ax25 = sk_to_ax25(sk);
555		555
556	switch (optname) {	556	switch (optname) {
557	case AX25_WINDOW:	557	case AX25_WINDOW:
@@ -697,7 +697,7 @@ static int ax25_getsockopt(struct socket *sock, int level, int optname, · 139 unmodified lines
697	length = min_t(unsigned int, maxlen, sizeof(int));	697	length = min_t(unsigned int, maxlen, sizeof(int));
698		698
699	lock_sock(sk);	699	lock_sock(sk);
700	ax25 = ax25_sk(sk);	700	ax25 = sk_to_ax25(sk);
701		701
702	switch (optname) {	702	switch (optname) {
703	case AX25_WINDOW:	703	case AX25_WINDOW:
@@ -796,7 +796,7 @@ out: · 92 unmodified lines
796	static struct proto ax25_proto = {	796	static struct proto ax25_proto = {
797	.name = "AX25",	797	.name = "AX25",
798	.owner = THIS_MODULE,	798	.owner = THIS_MODULE,
799	.obj_size = sizeof(struct sock),	799	.obj_size = sizeof(struct ax25_sock),
800	};	800	};
801		801
802	static int ax25_create(struct net net, struct socket sock, int protocol,	802	static int ax25_create(struct net net, struct socket sock, int protocol,
@@ -858,7 +858,7 @@ static int ax25_create(struct net net, struct socket sock, int protocol, · 55 unmodified lines
858	if (sk == NULL)	858	if (sk == NULL)
859	return -ENOMEM;	859	return -ENOMEM;
860		860
861	ax25 = sk->sk_protinfo = ax25_create_cb();	861	ax25 = ax25_sk(sk)->cb = ax25_create_cb();
862	if (!ax25) {	862	if (!ax25) {
863	sk_free(sk);	863	sk_free(sk);
864	return -ENOMEM;	864	return -ENOMEM;
@@ -910,7 +910,7 @@ struct sock ax25_make_new(struct sock osk, struct ax25_dev *ax25_dev) · 45 unmodified lines
910	sk->sk_state = TCP_ESTABLISHED;	910	sk->sk_state = TCP_ESTABLISHED;
911	sock_copy_flags(sk, osk);	911	sock_copy_flags(sk, osk);
912		912
913	oax25 = ax25_sk(osk);	913	oax25 = sk_to_ax25(osk);
914		914
915	ax25->modulus = oax25->modulus;	915	ax25->modulus = oax25->modulus;
916	ax25->backoff = oax25->backoff;	916	ax25->backoff = oax25->backoff;
@@ -938,7 +938,7 @@ struct sock ax25_make_new(struct sock osk, struct ax25_dev *ax25_dev) · 21 unmodified lines
938	}	938	}
939	}	939	}
940		940
941	sk->sk_protinfo = ax25;	941	ax25_sk(sk)->cb = ax25;
942	sk->sk_destruct = ax25_free_sock;	942	sk->sk_destruct = ax25_free_sock;
943	ax25->sk = sk;	943	ax25->sk = sk;
944		944
@@ -956,7 +956,7 @@ static int ax25_release(struct socket *sock) · 11 unmodified lines
956	sock_hold(sk);	956	sock_hold(sk);
957	sock_orphan(sk);	957	sock_orphan(sk);
958	lock_sock(sk);	958	lock_sock(sk);
959	ax25 = ax25_sk(sk);	959	ax25 = sk_to_ax25(sk);
960		960
961	if (sk->sk_type == SOCK_SEQPACKET) {	961	if (sk->sk_type == SOCK_SEQPACKET) {
962	switch (ax25->state) {	962	switch (ax25->state) {
@@ -1066,7 +1066,7 @@ static int ax25_bind(struct socket sock, struct sockaddr uaddr, int addr_len) · 103 unmodified lines
1066		1066
1067	lock_sock(sk);	1067	lock_sock(sk);
1068		1068
1069	ax25 = ax25_sk(sk);	1069	ax25 = sk_to_ax25(sk);
1070	if (!sock_flag(sk, SOCK_ZAPPED)) {	1070	if (!sock_flag(sk, SOCK_ZAPPED)) {
1071	err = -EINVAL;	1071	err = -EINVAL;
1072	goto out;	1072	goto out;
@@ -1113,7 +1113,7 @@ static int __must_check ax25_connect(struct socket *sock, · 40 unmodified lines
1113	struct sockaddr *uaddr, int addr_len, int flags)	1113	struct sockaddr *uaddr, int addr_len, int flags)
1114	{	1114	{
1115	struct sock *sk = sock->sk;	1115	struct sock *sk = sock->sk;
1116	ax25_cb ax25 = ax25_sk(sk), ax25t;	1116	ax25_cb ax25 = sk_to_ax25(sk), ax25t;
1117	struct full_sockaddr_ax25 fsa = (struct full_sockaddr_ax25 )uaddr;	1117	struct full_sockaddr_ax25 fsa = (struct full_sockaddr_ax25 )uaddr;
1118	ax25_digi *digi = NULL;	1118	ax25_digi *digi = NULL;
1119	int ct = 0, err = 0;	1119	int ct = 0, err = 0;
@@ -1394,7 +1394,7 @@ static int ax25_getname(struct socket sock, struct sockaddr uaddr, · 274 unmodified lines
1394		1394
1395	memset(fsa, 0, sizeof(*fsa));	1395	memset(fsa, 0, sizeof(*fsa));
1396	lock_sock(sk);	1396	lock_sock(sk);
1397	ax25 = ax25_sk(sk);	1397	ax25 = sk_to_ax25(sk);
1398		1398
1399	if (peer != 0) {	1399	if (peer != 0) {
1400	if (sk->sk_state != TCP_ESTABLISHED) {	1400	if (sk->sk_state != TCP_ESTABLISHED) {
@@ -1446,7 +1446,7 @@ static int ax25_sendmsg(struct socket sock, struct msghdr msg, size_t len) · 45 unmodified lines
1446	return -EINVAL;	1446	return -EINVAL;
1447		1447
1448	lock_sock(sk);	1448	lock_sock(sk);
1449	ax25 = ax25_sk(sk);	1449	ax25 = sk_to_ax25(sk);
1450		1450
1451	if (sock_flag(sk, SOCK_ZAPPED)) {	1451	if (sock_flag(sk, SOCK_ZAPPED)) {
1452	err = -EADDRNOTAVAIL;	1452	err = -EADDRNOTAVAIL;
@@ -1621,7 +1621,7 @@ static int ax25_recvmsg(struct socket sock, struct msghdr msg, size_t size, · 168 unmodified lines
1621	if (skb == NULL)	1621	if (skb == NULL)
1622	goto out;	1622	goto out;
1623		1623
1624	if (!ax25_sk(sk)->pidincl)	1624	if (!sk_to_ax25(sk)->pidincl)
1625	skb_pull(skb, 1); /* Remove PID */	1625	skb_pull(skb, 1); /* Remove PID */
1626		1626
1627	skb_reset_transport_header(skb);	1627	skb_reset_transport_header(skb);
@@ -1762,7 +1762,7 @@ static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) · 134 unmodified lines
1762		1762
1763	case SIOCAX25GETINFO:	1763	case SIOCAX25GETINFO:
1764	case SIOCAX25GETINFOOLD: {	1764	case SIOCAX25GETINFOOLD: {
1765	ax25_cb *ax25 = ax25_sk(sk);	1765	ax25_cb *ax25 = sk_to_ax25(sk);
1766	struct ax25_info_struct ax25_info;	1766	struct ax25_info_struct ax25_info;
1767		1767
1768	ax25_info.t1 = ax25->t1 / HZ;	1768	ax25_info.t1 = ax25->t1 / HZ;

net/ax25/ax25_in.c+1−1

@@ -353,7 +353,7 @@ static int ax25_rcv(struct sk_buff skb, struct net_device dev, · 352 unmodified lines
353	return 0;	353	return 0;
354	}	354	}
355		355
356	ax25 = ax25_sk(make);	356	ax25 = sk_to_ax25(make);
357	skb_set_owner_r(skb, make);	357	skb_set_owner_r(skb, make);
358	skb_queue_head(&sk->sk_receive_queue, skb);	358	skb_queue_head(&sk->sk_receive_queue, skb);
359		359

net/core/flow_dissector.c+1−1

@@ -129,7 +129,7 @@ bool __skb_flow_dissect(const struct sk_buff *skb, · 128 unmodified lines
129	struct flow_dissector_key_ports *key_ports;	129	struct flow_dissector_key_ports *key_ports;
130	struct flow_dissector_key_tags *key_tags;	130	struct flow_dissector_key_tags *key_tags;
131	struct flow_dissector_key_keyid *key_keyid;	131	struct flow_dissector_key_keyid *key_keyid;
132	u8 ip_proto;	132	u8 ip_proto = 0;
133		133
134	if (!data) {	134	if (!data) {
135	data = skb->data;	135	data = skb->data;

net/core/sock.c+1−2

 static void __sk_free(struct sock *sk)
 {
-	if (unlikely(sock_diag_has_destroy_listeners(sk)))
+	if (unlikely(sock_diag_has_destroy_listeners(sk) && sk->sk_net_refcnt))
 		sock_diag_broadcast_destroy(sk);
 	else
 		sk_destruct(sk);
 static void sock_def_destruct(struct sock *sk)
 {
-	kfree(sk->sk_protinfo);
 }
 void sk_send_sigurg(struct sock *sk)

net/dsa/slave.c+1−1

@@ -112,7 +112,7 @@ static int dsa_slave_open(struct net_device *dev) · 111 unmodified lines
112		112
113	clear_promisc:	113	clear_promisc:
114	if (dev->flags & IFF_PROMISC)	114	if (dev->flags & IFF_PROMISC)
115	dev_set_promiscuity(master, 0);	115	dev_set_promiscuity(master, -1);
116	clear_allmulti:	116	clear_allmulti:
117	if (dev->flags & IFF_ALLMULTI)	117	if (dev->flags & IFF_ALLMULTI)
118	dev_set_allmulti(master, -1);	118	dev_set_allmulti(master, -1);

net/ipv4/fib_semantics.c+2−2

@@ -1045,7 +1045,7 @@ int fib_dump_info(struct sk_buff *skb, u32 portid, u32 seq, int event, · 1044 unmodified lines
1045	nla_put_u32(skb, RTA_OIF, fi->fib_nh->nh_oif))	1045	nla_put_u32(skb, RTA_OIF, fi->fib_nh->nh_oif))
1046	goto nla_put_failure;	1046	goto nla_put_failure;
1047	if (fi->fib_nh->nh_flags & RTNH_F_LINKDOWN) {	1047	if (fi->fib_nh->nh_flags & RTNH_F_LINKDOWN) {
1048	in_dev = __in_dev_get_rcu(fi->fib_nh->nh_dev);	1048	in_dev = __in_dev_get_rtnl(fi->fib_nh->nh_dev);
1049	if (in_dev &&	1049	if (in_dev &&
1050	IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev))	1050	IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev))
1051	rtm->rtm_flags \|= RTNH_F_DEAD;	1051	rtm->rtm_flags \|= RTNH_F_DEAD;
@@ -1074,7 +1074,7 @@ int fib_dump_info(struct sk_buff *skb, u32 portid, u32 seq, int event, · 22 unmodified lines
1074		1074
1075	rtnh->rtnh_flags = nh->nh_flags & 0xFF;	1075	rtnh->rtnh_flags = nh->nh_flags & 0xFF;
1076	if (nh->nh_flags & RTNH_F_LINKDOWN) {	1076	if (nh->nh_flags & RTNH_F_LINKDOWN) {
1077	in_dev = __in_dev_get_rcu(nh->nh_dev);	1077	in_dev = __in_dev_get_rtnl(nh->nh_dev);
1078	if (in_dev &&	1078	if (in_dev &&
1079	IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev))	1079	IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev))
1080	rtnh->rtnh_flags \|= RTNH_F_DEAD;	1080	rtnh->rtnh_flags \|= RTNH_F_DEAD;

net/sched/cls_flower.c+2−2

@@ -216,8 +216,8 @@ static const struct nla_policy fl_policy[TCA_FLOWER_MAX + 1] = { · 215 unmodified lines
216	[TCA_FLOWER_KEY_IPV6_DST_MASK] = { .len = sizeof(struct in6_addr) },	216	[TCA_FLOWER_KEY_IPV6_DST_MASK] = { .len = sizeof(struct in6_addr) },
217	[TCA_FLOWER_KEY_TCP_SRC] = { .type = NLA_U16 },	217	[TCA_FLOWER_KEY_TCP_SRC] = { .type = NLA_U16 },
218	[TCA_FLOWER_KEY_TCP_DST] = { .type = NLA_U16 },	218	[TCA_FLOWER_KEY_TCP_DST] = { .type = NLA_U16 },
219	[TCA_FLOWER_KEY_TCP_SRC] = { .type = NLA_U16 },	219	[TCA_FLOWER_KEY_UDP_SRC] = { .type = NLA_U16 },
220	[TCA_FLOWER_KEY_TCP_DST] = { .type = NLA_U16 },	220	[TCA_FLOWER_KEY_UDP_DST] = { .type = NLA_U16 },
221	};	221	};
222		222
223	static void fl_set_key_val(struct nlattr **tb,	223	static void fl_set_key_val(struct nlattr **tb,

net/sctp/output.c+3−1

@@ -599,7 +599,9 @@ out: · 598 unmodified lines
599	return err;	599	return err;
600	no_route:	600	no_route:
601	kfree_skb(nskb);	601	kfree_skb(nskb);
602	IP_INC_STATS(sock_net(asoc->base.sk), IPSTATS_MIB_OUTNOROUTES);	602
		603	if (asoc)
		604	IP_INC_STATS(sock_net(asoc->base.sk), IPSTATS_MIB_OUTNOROUTES);
603		605
604	/* FIXME: Returning the 'err' will effect all the associations	606	/* FIXME: Returning the 'err' will effect all the associations
605	* associated with a socket, although only one of the paths of the	607	* associated with a socket, although only one of the paths of the

net/sctp/socket.c+0−6

 	if (sp->subscribe.sctp_data_io_event)
 		sctp_ulpevent_read_sndrcvinfo(event, msg);
-#if 0
-	/* FIXME: we should be calling IP/IPv6 layers.  */
-	if (sk->sk_protinfo.af_inet.cmsg_flags)
-		ip_cmsg_recv(msg, skb);
-#endif
 	err = copied;
 	/* If skb's length exceeds the user's buffer, update the skb and

net/tipc/bcast.c+5−0

@@ -108,6 +108,11 @@ void tipc_bclink_remove_node(struct net *net, u32 addr) · 107 unmodified lines
108		108
109	tipc_bclink_lock(net);	109	tipc_bclink_lock(net);
110	tipc_nmap_remove(&tn->bclink->bcast_nodes, addr);	110	tipc_nmap_remove(&tn->bclink->bcast_nodes, addr);
		111
		112	/* Last node? => reset backlog queue */
		113	if (!tn->bclink->bcast_nodes.count)
		114	tipc_link_purge_backlog(&tn->bclink->link);
		115
111	tipc_bclink_unlock(net);	116	tipc_bclink_unlock(net);
112	}	117	}
113		118

net/tipc/link.c+1−1

@@ -404,7 +404,7 @@ void tipc_link_reset_fragments(struct tipc_link *l_ptr) · 403 unmodified lines
404	l_ptr->reasm_buf = NULL;	404	l_ptr->reasm_buf = NULL;
405	}	405	}
406		406
407	static void tipc_link_purge_backlog(struct tipc_link *l)	407	void tipc_link_purge_backlog(struct tipc_link *l)
408	{	408	{
409	__skb_queue_purge(&l->backlogq);	409	__skb_queue_purge(&l->backlogq);
410	l->backlog[TIPC_LOW_IMPORTANCE].len = 0;	410	l->backlog[TIPC_LOW_IMPORTANCE].len = 0;

net/tipc/link.h+1−0

@@ -218,6 +218,7 @@ void tipc_link_reset_fragments(struct tipc_link *l_ptr); · 217 unmodified lines
218	int tipc_link_is_up(struct tipc_link *l_ptr);	218	int tipc_link_is_up(struct tipc_link *l_ptr);
219	int tipc_link_is_active(struct tipc_link *l_ptr);	219	int tipc_link_is_active(struct tipc_link *l_ptr);
220	void tipc_link_purge_queues(struct tipc_link *l_ptr);	220	void tipc_link_purge_queues(struct tipc_link *l_ptr);
		221	void tipc_link_purge_backlog(struct tipc_link *l);
221	void tipc_link_reset_all(struct tipc_node *node);	222	void tipc_link_reset_all(struct tipc_node *node);
222	void tipc_link_reset(struct tipc_link *l_ptr);	223	void tipc_link_reset(struct tipc_link *l_ptr);
223	int tipc_link_xmit_skb(struct net net, struct sk_buff skb, u32 dest,	224	int tipc_link_xmit_skb(struct net net, struct sk_buff skb, u32 dest,

@@ -73,7 +73,7 @@ · 72 unmodified lines
73	#define MMC_RX_OCTETCOUNT_G 0x00000188	73	#define MMC_RX_OCTETCOUNT_G 0x00000188
74	#define MMC_RX_BROADCASTFRAME_G 0x0000018c	74	#define MMC_RX_BROADCASTFRAME_G 0x0000018c
75	#define MMC_RX_MULTICASTFRAME_G 0x00000190	75	#define MMC_RX_MULTICASTFRAME_G 0x00000190
76	#define MMC_RX_CRC_ERRROR 0x00000194	76	#define MMC_RX_CRC_ERROR 0x00000194
77	#define MMC_RX_ALIGN_ERROR 0x00000198	77	#define MMC_RX_ALIGN_ERROR 0x00000198
78	#define MMC_RX_RUN_ERROR 0x0000019C	78	#define MMC_RX_RUN_ERROR 0x0000019C
79	#define MMC_RX_JABBER_ERROR 0x000001A0	79	#define MMC_RX_JABBER_ERROR 0x000001A0
@@ -196,7 +196,7 @@ void dwmac_mmc_read(void __iomem ioaddr, struct stmmac_counters mmc) · 116 unmodified lines
196	mmc->mmc_rx_octetcount_g += readl(ioaddr + MMC_RX_OCTETCOUNT_G);	196	mmc->mmc_rx_octetcount_g += readl(ioaddr + MMC_RX_OCTETCOUNT_G);
197	mmc->mmc_rx_broadcastframe_g += readl(ioaddr + MMC_RX_BROADCASTFRAME_G);	197	mmc->mmc_rx_broadcastframe_g += readl(ioaddr + MMC_RX_BROADCASTFRAME_G);
198	mmc->mmc_rx_multicastframe_g += readl(ioaddr + MMC_RX_MULTICASTFRAME_G);	198	mmc->mmc_rx_multicastframe_g += readl(ioaddr + MMC_RX_MULTICASTFRAME_G);
199	mmc->mmc_rx_crc_error += readl(ioaddr + MMC_RX_CRC_ERRROR);	199	mmc->mmc_rx_crc_error += readl(ioaddr + MMC_RX_CRC_ERROR);
200	mmc->mmc_rx_align_error += readl(ioaddr + MMC_RX_ALIGN_ERROR);	200	mmc->mmc_rx_align_error += readl(ioaddr + MMC_RX_ALIGN_ERROR);
201	mmc->mmc_rx_run_error += readl(ioaddr + MMC_RX_RUN_ERROR);	201	mmc->mmc_rx_run_error += readl(ioaddr + MMC_RX_RUN_ERROR);
202	mmc->mmc_rx_jabber_error += readl(ioaddr + MMC_RX_JABBER_ERROR);	202	mmc->mmc_rx_jabber_error += readl(ioaddr + MMC_RX_JABBER_ERROR);