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

Pull networking fixes from David Miller: "One last pull request before heading to Vancouver for LPC, here we have: 1) Don't forget to free VSI contexts during ice driver unload, from Victor Raj. 2) Don't forget napi delete calls during device remove in ice driver, from Dave Ertman. 3) Don't request VLAN tag insertion of ibmvnic device when SKB doesn't have VLAN tags at all. 4) IPV4 frag handling code has to accomodate the situation where two threads try to insert the same fragment into the hash table at the same time. From Eric Dumazet. 5) Relatedly, don't flow separate on protocol ports for fragmented frames, also from Eric Dumazet. 6) Memory leaks in qed driver, from Denis Bolotin. 7) Correct valid MTU range in smsc95xx driver, from Stefan Wahren. 8) Validate cls_flower nested policies properly, from Jakub Kicinski. 9) Clearing of stats counters in mc88e6xxx driver doesn't retain important bits in the G1_STATS_OP register causing the chip to hang. Fix from Andrew Lunn" * git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (41 commits) act_mirred: clear skb->tstamp on redirect net: dsa: mv88e6xxx: Fix clearing of stats counters tipc: fix link re-establish failure net: sched: cls_flower: validate nested enc_opts_policy to avoid warning net: mvneta: correct typo flow_dissector: do not dissect l4 ports for fragments net: qualcomm: rmnet: Fix incorrect assignment of real_dev net: aquantia: allow rx checksum offload configuration net: aquantia: invalid checksumm offload implementation net: aquantia: fixed enable unicast on 32 macvlan net: aquantia: fix potential IOMMU fault after driver unbind net: aquantia: synchronized flow control between mac/phy net: smsc95xx: Fix MTU range net: stmmac: Fix RX packet size > 8191 qed: Fix potential memory corruption qed: Fix SPQ entries not returned to pool in error flows qed: Fix blocking/unlimited SPQ entries leak qed: Fix memory/entry leak in qed_init_sp_request() inet: frags: better deal with smp races net: hns3: bugfix for not checking return value ...

Linus Torvalds committed 8 years ago

Commit 7a3765e2 parents e12e00e 7236ead54 files · +430 −199Browse files

Unified · Split

54 files

drivers/net/dsa/mv88e6xxx/global1.c +2 −0
drivers/net/ethernet/aquantia/atlantic/aq_ethtool.c +4 −4
drivers/net/ethernet/aquantia/atlantic/aq_hw.h +6 −0
drivers/net/ethernet/aquantia/atlantic/aq_main.c +8 −2
drivers/net/ethernet/aquantia/atlantic/aq_nic.c +15 −3
drivers/net/ethernet/aquantia/atlantic/aq_nic.h +1 −1
drivers/net/ethernet/aquantia/atlantic/aq_ring.c +23 −12
drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_b0.c +38 −23
drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c +8 −0
drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h +3 −0
drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h +18 −0
drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils_fw2x.c +21 −0
drivers/net/ethernet/hisilicon/hns3/hns3_enet.c +2 −1
drivers/net/ethernet/ibm/ibmvnic.c +1 −1
drivers/net/ethernet/intel/i40e/i40e_main.c +5 −3
drivers/net/ethernet/intel/ice/ice.h +3 −1
drivers/net/ethernet/intel/ice/ice_common.c +3 −0
drivers/net/ethernet/intel/ice/ice_ethtool.c +6 −1
drivers/net/ethernet/intel/ice/ice_hw_autogen.h +2 −0
drivers/net/ethernet/intel/ice/ice_lib.c +2 −1
drivers/net/ethernet/intel/ice/ice_main.c +48 −38
drivers/net/ethernet/intel/ice/ice_switch.c +12 −0
drivers/net/ethernet/intel/ice/ice_switch.h +2 −0
drivers/net/ethernet/intel/ice/ice_txrx.c +6 −5
drivers/net/ethernet/intel/ice/ice_txrx.h +15 −2
drivers/net/ethernet/intel/ice/ice_type.h +1 −1
drivers/net/ethernet/intel/ice/ice_virtchnl_pf.c +1 −3
drivers/net/ethernet/intel/igb/igb_ptp.c +7 −5
drivers/net/ethernet/marvell/mvneta.c +2 −2
drivers/net/ethernet/qlogic/qed/qed_fcoe.c +8 −3
drivers/net/ethernet/qlogic/qed/qed_iscsi.c +1 −0
drivers/net/ethernet/qlogic/qed/qed_l2.c +8 −4
drivers/net/ethernet/qlogic/qed/qed_rdma.c +1 −0
drivers/net/ethernet/qlogic/qed/qed_roce.c +1 −0
drivers/net/ethernet/qlogic/qed/qed_sp.h +14 −0
drivers/net/ethernet/qlogic/qed/qed_sp_commands.c +20 −2
drivers/net/ethernet/qlogic/qed/qed_spq.c +35 −34
drivers/net/ethernet/qlogic/qed/qed_sriov.c +1 −0
drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c +5 −3
drivers/net/ethernet/qualcomm/rmnet/rmnet_vnd.c +3 −3
drivers/net/ethernet/stmicro/stmmac/common.h +2 −1
drivers/net/ethernet/stmicro/stmmac/descs_com.h +1 −1
drivers/net/ethernet/stmicro/stmmac/enh_desc.c +1 −1
drivers/net/ethernet/stmicro/stmmac/ring_mode.c +1 −1
drivers/net/fddi/defza.c +4 −3
drivers/net/fddi/defza.h +2 −1
drivers/net/phy/broadcom.c +16 −2
drivers/net/usb/smsc95xx.c +2 −0
net/core/flow_dissector.c +2 −2
net/ipv4/inet_fragment.c +15 −14
net/sched/act_mirred.c +2 −1
net/sched/cls_flower.c +13 −1
net/sched/sch_netem.c +0 −9
net/tipc/link.c +7 −4

drivers/net/dsa/mv88e6xxx/global1.c+2−0

@@ -567,6 +567,8 @@ int mv88e6xxx_g1_stats_clear(struct mv88e6xxx_chip *chip) · 566 unmodified lines
567	567	if (err)
568	568	return err;
569	569
	570	+ /* Keep the histogram mode bits */
	571	+ val &= MV88E6XXX_G1_STATS_OP_HIST_RX_TX;
570	572	val \|= MV88E6XXX_G1_STATS_OP_BUSY \| MV88E6XXX_G1_STATS_OP_FLUSH_ALL;
571	573
572	574	err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_STATS_OP, val);

drivers/net/ethernet/aquantia/atlantic/aq_ethtool.c+4−4

@@ -407,13 +407,13 @@ static void aq_ethtool_get_pauseparam(struct net_device *ndev, · 406 unmodified lines
407	407	struct ethtool_pauseparam *pause)
408	408	{
409	409	struct aq_nic_s *aq_nic = netdev_priv(ndev);
	410	+ u32 fc = aq_nic->aq_nic_cfg.flow_control;
410	411
411	412	pause->autoneg = 0;
412	413
413		− if (aq_nic->aq_hw->aq_nic_cfg->flow_control & AQ_NIC_FC_RX)
414		− pause->rx_pause = 1;
415		− if (aq_nic->aq_hw->aq_nic_cfg->flow_control & AQ_NIC_FC_TX)
416		− pause->tx_pause = 1;
	414	+ pause->rx_pause = !!(fc & AQ_NIC_FC_RX);
	415	+ pause->tx_pause = !!(fc & AQ_NIC_FC_TX);
	416	+
417	417	}
418	418
419	419	static int aq_ethtool_set_pauseparam(struct net_device *ndev,

drivers/net/ethernet/aquantia/atlantic/aq_hw.h+6−0

@@ -204,6 +204,10 @@ struct aq_hw_ops { · 203 unmodified lines
204	204
205	205	int (hw_get_fw_version)(struct aq_hw_s self, u32 *fw_version);
206	206
	207	+ int (hw_set_offload)(struct aq_hw_s self,
	208	+ struct aq_nic_cfg_s *aq_nic_cfg);
	209	+
	210	+ int (hw_set_fc)(struct aq_hw_s self, u32 fc, u32 tc);
207	211	};
208	212
209	213	struct aq_fw_ops {
@@ -226,6 +230,8 @@ struct aq_fw_ops { · 16 unmodified lines
226	230
227	231	int (update_stats)(struct aq_hw_s self);
228	232
	233	+ u32 (get_flow_control)(struct aq_hw_s self, u32 *fcmode);
	234	+
229	235	int (set_flow_control)(struct aq_hw_s self);
230	236
231	237	int (set_power)(struct aq_hw_s self, unsigned int power_state,

drivers/net/ethernet/aquantia/atlantic/aq_main.c+8−2

@@ -99,8 +99,11 @@ static int aq_ndev_set_features(struct net_device *ndev, · 98 unmodified lines
99	99	struct aq_nic_s *aq_nic = netdev_priv(ndev);
100	100	struct aq_nic_cfg_s *aq_cfg = aq_nic_get_cfg(aq_nic);
101	101	bool is_lro = false;
	102	+ int err = 0;
	103	+
	104	+ aq_cfg->features = features;
102	105
103		− if (aq_cfg->hw_features & NETIF_F_LRO) {
	106	+ if (aq_cfg->aq_hw_caps->hw_features & NETIF_F_LRO) {
104	107	is_lro = features & NETIF_F_LRO;
105	108
106	109	if (aq_cfg->is_lro != is_lro) {
@@ -112,8 +115,11 @@ static int aq_ndev_set_features(struct net_device *ndev, · 5 unmodified lines
112	115	}
113	116	}
114	117	}
	118	+ if ((aq_nic->ndev->features ^ features) & NETIF_F_RXCSUM)
	119	+ err = aq_nic->aq_hw_ops->hw_set_offload(aq_nic->aq_hw,
	120	+ aq_cfg);
115	121
116		− return 0;
	122	+ return err;
117	123	}
118	124
119	125	static int aq_ndev_set_mac_address(struct net_device ndev, void addr)

drivers/net/ethernet/aquantia/atlantic/aq_nic.c+15−3

@@ -118,12 +118,13 @@ void aq_nic_cfg_start(struct aq_nic_s *self) · 117 unmodified lines
118	118	}
119	119
120	120	cfg->link_speed_msk &= cfg->aq_hw_caps->link_speed_msk;
121		− cfg->hw_features = cfg->aq_hw_caps->hw_features;
	121	+ cfg->features = cfg->aq_hw_caps->hw_features;
122	122	}
123	123
124	124	static int aq_nic_update_link_status(struct aq_nic_s *self)
125	125	{
126	126	int err = self->aq_fw_ops->update_link_status(self->aq_hw);
	127	+ u32 fc = 0;
127	128
128	129	if (err)
129	130	return err;
@@ -133,6 +134,15 @@ static int aq_nic_update_link_status(struct aq_nic_s *self) · 3 unmodified lines
133	134	AQ_CFG_DRV_NAME, self->link_status.mbps,
134	135	self->aq_hw->aq_link_status.mbps);
135	136	aq_nic_update_interrupt_moderation_settings(self);
	137	+
	138	+ /* Driver has to update flow control settings on RX block
	139	+ * on any link event.
	140	+ * We should query FW whether it negotiated FC.
	141	+ */
	142	+ if (self->aq_fw_ops->get_flow_control)
	143	+ self->aq_fw_ops->get_flow_control(self->aq_hw, &fc);
	144	+ if (self->aq_hw_ops->hw_set_fc)
	145	+ self->aq_hw_ops->hw_set_fc(self->aq_hw, fc, 0);
136	146	}
137	147
138	148	self->link_status = self->aq_hw->aq_link_status;
@@ -590,7 +600,7 @@ int aq_nic_set_multicast_list(struct aq_nic_s self, struct net_device ndev) · 451 unmodified lines
590	600	}
591	601	}
592	602
593		− if (i > 0 && i < AQ_HW_MULTICAST_ADDRESS_MAX) {
	603	+ if (i > 0 && i <= AQ_HW_MULTICAST_ADDRESS_MAX) {
594	604	packet_filter \|= IFF_MULTICAST;
595	605	self->mc_list.count = i;
596	606	self->aq_hw_ops->hw_multicast_list_set(self->aq_hw,
@@ -772,7 +782,9 @@ void aq_nic_get_link_ksettings(struct aq_nic_s *self, · 175 unmodified lines
772	782	ethtool_link_ksettings_add_link_mode(cmd, advertising,
773	783	Pause);
774	784
775		− if (self->aq_nic_cfg.flow_control & AQ_NIC_FC_TX)
	785	+ /* Asym is when either RX or TX, but not both */
	786	+ if (!!(self->aq_nic_cfg.flow_control & AQ_NIC_FC_TX) ^
	787	+ !!(self->aq_nic_cfg.flow_control & AQ_NIC_FC_RX))
776	788	ethtool_link_ksettings_add_link_mode(cmd, advertising,
777	789	Asym_Pause);
778	790

drivers/net/ethernet/aquantia/atlantic/aq_nic.h+1−1

@@ -23,7 +23,7 @@ struct aq_vec_s; · 22 unmodified lines
23	23
24	24	struct aq_nic_cfg_s {
25	25	const struct aq_hw_caps_s *aq_hw_caps;
26		− u64 hw_features;
	26	+ u64 features;
27	27	u32 rxds; /* rx ring size, descriptors # */
28	28	u32 txds; /* tx ring size, descriptors # */
29	29	u32 vecs; /* vecs==allocated irqs */

drivers/net/ethernet/aquantia/atlantic/aq_ring.c+23−12

@@ -172,6 +172,27 @@ bool aq_ring_tx_clean(struct aq_ring_s *self) · 171 unmodified lines
172	172	return !!budget;
173	173	}
174	174
	175	+static void aq_rx_checksum(struct aq_ring_s *self,
	176	+ struct aq_ring_buff_s *buff,
	177	+ struct sk_buff *skb)
	178	+{
	179	+ if (!(self->aq_nic->ndev->features & NETIF_F_RXCSUM))
	180	+ return;
	181	+
	182	+ if (unlikely(buff->is_cso_err)) {
	183	+ ++self->stats.rx.errors;
	184	+ skb->ip_summed = CHECKSUM_NONE;
	185	+ return;
	186	+ }
	187	+ if (buff->is_ip_cso) {
	188	+ __skb_incr_checksum_unnecessary(skb);
	189	+ if (buff->is_udp_cso \|\| buff->is_tcp_cso)
	190	+ __skb_incr_checksum_unnecessary(skb);
	191	+ } else {
	192	+ skb->ip_summed = CHECKSUM_NONE;
	193	+ }
	194	+}
	195	+
175	196	#define AQ_SKB_ALIGN SKB_DATA_ALIGN(sizeof(struct skb_shared_info))
176	197	int aq_ring_rx_clean(struct aq_ring_s *self,
177	198	struct napi_struct *napi,
@@ -267,18 +288,8 @@ int aq_ring_rx_clean(struct aq_ring_s *self, · 89 unmodified lines
267	288	}
268	289
269	290	skb->protocol = eth_type_trans(skb, ndev);
270		− if (unlikely(buff->is_cso_err)) {
271		− ++self->stats.rx.errors;
272		− skb->ip_summed = CHECKSUM_NONE;
273		− } else {
274		− if (buff->is_ip_cso) {
275		− __skb_incr_checksum_unnecessary(skb);
276		− if (buff->is_udp_cso \|\| buff->is_tcp_cso)
277		− __skb_incr_checksum_unnecessary(skb);
278		− } else {
279		− skb->ip_summed = CHECKSUM_NONE;
280		− }
281		− }
	291	+
	292	+ aq_rx_checksum(self, buff, skb);
282	293
283	294	skb_set_hash(skb, buff->rss_hash,
284	295	buff->is_hash_l4 ? PKT_HASH_TYPE_L4 :

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_b0.c+38−23

@@ -100,12 +100,17 @@ static int hw_atl_b0_hw_reset(struct aq_hw_s *self) · 99 unmodified lines
100	100	return err;
101	101	}
102	102
	103	+static int hw_atl_b0_set_fc(struct aq_hw_s *self, u32 fc, u32 tc)
	104	+{
	105	+ hw_atl_rpb_rx_xoff_en_per_tc_set(self, !!(fc & AQ_NIC_FC_RX), tc);
	106	+ return 0;
	107	+}
	108	+
103	109	static int hw_atl_b0_hw_qos_set(struct aq_hw_s *self)
104	110	{
105	111	u32 tc = 0U;
106	112	u32 buff_size = 0U;
107	113	unsigned int i_priority = 0U;
108		− bool is_rx_flow_control = false;
109	114
110	115	/* TPS Descriptor rate init */
111	116	hw_atl_tps_tx_pkt_shed_desc_rate_curr_time_res_set(self, 0x0U);
@@ -138,7 +143,6 @@ static int hw_atl_b0_hw_qos_set(struct aq_hw_s *self) · 26 unmodified lines
138	143
139	144	/* QoS Rx buf size per TC */
140	145	tc = 0;
141		− is_rx_flow_control = (AQ_NIC_FC_RX & self->aq_nic_cfg->flow_control);
142	146	buff_size = HW_ATL_B0_RXBUF_MAX;
143	147
144	148	hw_atl_rpb_rx_pkt_buff_size_per_tc_set(self, buff_size, tc);
@@ -150,7 +154,8 @@ static int hw_atl_b0_hw_qos_set(struct aq_hw_s *self) · 5 unmodified lines
150	154	(buff_size *
151	155	(1024U / 32U) * 50U) /
152	156	100U, tc);
153		− hw_atl_rpb_rx_xoff_en_per_tc_set(self, is_rx_flow_control ? 1U : 0U, tc);
	157	+
	158	+ hw_atl_b0_set_fc(self, self->aq_nic_cfg->flow_control, tc);
154	159
155	160	/* QoS 802.1p priority -> TC mapping */
156	161	for (i_priority = 8U; i_priority--;)
@@ -229,8 +234,10 @@ static int hw_atl_b0_hw_offload_set(struct aq_hw_s *self, · 72 unmodified lines
229	234	hw_atl_tpo_tcp_udp_crc_offload_en_set(self, 1);
230	235
231	236	/* RX checksums offloads*/
232		− hw_atl_rpo_ipv4header_crc_offload_en_set(self, 1);
233		− hw_atl_rpo_tcp_udp_crc_offload_en_set(self, 1);
	237	+ hw_atl_rpo_ipv4header_crc_offload_en_set(self, !!(aq_nic_cfg->features &
	238	+ NETIF_F_RXCSUM));
	239	+ hw_atl_rpo_tcp_udp_crc_offload_en_set(self, !!(aq_nic_cfg->features &
	240	+ NETIF_F_RXCSUM));
234	241
235	242	/* LSO offloads*/
236	243	hw_atl_tdm_large_send_offload_en_set(self, 0xFFFFFFFFU);
@@ -655,9 +662,9 @@ static int hw_atl_b0_hw_ring_rx_receive(struct aq_hw_s *self, · 418 unmodified lines
655	662	struct hw_atl_rxd_wb_s rxd_wb = (struct hw_atl_rxd_wb_s )
656	663	&ring->dx_ring[ring->hw_head * HW_ATL_B0_RXD_SIZE];
657	664
658		− unsigned int is_err = 1U;
659	665	unsigned int is_rx_check_sum_enabled = 0U;
660	666	unsigned int pkt_type = 0U;
	667	+ u8 rx_stat = 0U;
661	668
662	669	if (!(rxd_wb->status & 0x1U)) { /* RxD is not done */
663	670	break;
@@ -665,35 +672,35 @@ static int hw_atl_b0_hw_ring_rx_receive(struct aq_hw_s *self, · 1 unmodified line
665	672
666	673	buff = &ring->buff_ring[ring->hw_head];
667	674
668		− is_err = (0x0000003CU & rxd_wb->status);
	675	+ rx_stat = (0x0000003CU & rxd_wb->status) >> 2;
669	676
670	677	is_rx_check_sum_enabled = (rxd_wb->type) & (0x3U << 19);
671		− is_err &= ~0x20U; /* exclude validity bit */
672	678
673	679	pkt_type = 0xFFU & (rxd_wb->type >> 4);
674	680
675		− if (is_rx_check_sum_enabled) {
676		− if (0x0U == (pkt_type & 0x3U))
677		− buff->is_ip_cso = (is_err & 0x08U) ? 0U : 1U;
	681	+ if (is_rx_check_sum_enabled & BIT(0) &&
	682	+ (0x0U == (pkt_type & 0x3U)))
	683	+ buff->is_ip_cso = (rx_stat & BIT(1)) ? 0U : 1U;
678	684
	685	+ if (is_rx_check_sum_enabled & BIT(1)) {
679	686	if (0x4U == (pkt_type & 0x1CU))
680		− buff->is_udp_cso = buff->is_cso_err ? 0U : 1U;
	687	+ buff->is_udp_cso = (rx_stat & BIT(2)) ? 0U :
	688	+ !!(rx_stat & BIT(3));
681	689	else if (0x0U == (pkt_type & 0x1CU))
682		− buff->is_tcp_cso = buff->is_cso_err ? 0U : 1U;
683		−
684		− /* Checksum offload workaround for small packets */
685		− if (rxd_wb->pkt_len <= 60) {
686		− buff->is_ip_cso = 0U;
687		− buff->is_cso_err = 0U;
688		− }
	690	+ buff->is_tcp_cso = (rx_stat & BIT(2)) ? 0U :
	691	+ !!(rx_stat & BIT(3));
	692	+ }
	693	+ buff->is_cso_err = !!(rx_stat & 0x6);
	694	+ /* Checksum offload workaround for small packets */
	695	+ if (unlikely(rxd_wb->pkt_len <= 60)) {
	696	+ buff->is_ip_cso = 0U;
	697	+ buff->is_cso_err = 0U;
689	698	}
690		−
691		− is_err &= ~0x18U;
692	699
693	700	dma_unmap_page(ndev, buff->pa, buff->len, DMA_FROM_DEVICE);
694	701
695		− if (is_err \|\| rxd_wb->type & 0x1000U) {
696		− /* status error or DMA error */
	702	+ if ((rx_stat & BIT(0)) \|\| rxd_wb->type & 0x1000U) {
	703	+ /* MAC error or DMA error */
697	704	buff->is_error = 1U;
698	705	} else {
699	706	if (self->aq_nic_cfg->is_rss) {
@@ -915,6 +922,12 @@ static int hw_atl_b0_hw_interrupt_moderation_set(struct aq_hw_s *self) · 215 unmodified lines
915	922	static int hw_atl_b0_hw_stop(struct aq_hw_s *self)
916	923	{
917	924	hw_atl_b0_hw_irq_disable(self, HW_ATL_B0_INT_MASK);
	925	+
	926	+ /* Invalidate Descriptor Cache to prevent writing to the cached
	927	+ * descriptors and to the data pointer of those descriptors
	928	+ */
	929	+ hw_atl_rdm_rx_dma_desc_cache_init_set(self, 1);
	930	+
918	931	return aq_hw_err_from_flags(self);
919	932	}
920	933
@@ -963,4 +976,6 @@ const struct aq_hw_ops hw_atl_ops_b0 = { · 42 unmodified lines
963	976	.hw_get_regs = hw_atl_utils_hw_get_regs,
964	977	.hw_get_hw_stats = hw_atl_utils_get_hw_stats,
965	978	.hw_get_fw_version = hw_atl_utils_get_fw_version,
	979	+ .hw_set_offload = hw_atl_b0_hw_offload_set,
	980	+ .hw_set_fc = hw_atl_b0_set_fc,
966	981	};

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.c+8−0

@@ -619,6 +619,14 @@ void hw_atl_rpb_rx_flow_ctl_mode_set(struct aq_hw_s *aq_hw, u32 rx_flow_ctl_mode · 618 unmodified lines
619	619	HW_ATL_RPB_RX_FC_MODE_SHIFT, rx_flow_ctl_mode);
620	620	}
621	621
	622	+void hw_atl_rdm_rx_dma_desc_cache_init_set(struct aq_hw_s *aq_hw, u32 init)
	623	+{
	624	+ aq_hw_write_reg_bit(aq_hw, HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_ADR,
	625	+ HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_MSK,
	626	+ HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_SHIFT,
	627	+ init);
	628	+}
	629	+
622	630	void hw_atl_rpb_rx_pkt_buff_size_per_tc_set(struct aq_hw_s *aq_hw,
623	631	u32 rx_pkt_buff_size_per_tc, u32 buffer)
624	632	{

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh.h+3−0

@@ -325,6 +325,9 @@ void hw_atl_rpb_rx_pkt_buff_size_per_tc_set(struct aq_hw_s *aq_hw, · 324 unmodified lines
325	325	u32 rx_pkt_buff_size_per_tc,
326	326	u32 buffer);
327	327
	328	+/* set rdm rx dma descriptor cache init */
	329	+void hw_atl_rdm_rx_dma_desc_cache_init_set(struct aq_hw_s *aq_hw, u32 init);
	330	+
328	331	/* set rx xoff enable (per tc) */
329	332	void hw_atl_rpb_rx_xoff_en_per_tc_set(struct aq_hw_s *aq_hw, u32 rx_xoff_en_per_tc,
330	333	u32 buffer);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_llh_internal.h+18−0

@@ -293,6 +293,24 @@ · 292 unmodified lines
293	293	/* default value of bitfield desc{d}_reset */
294	294	#define HW_ATL_RDM_DESCDRESET_DEFAULT 0x0
295	295
	296	+/* rdm_desc_init_i bitfield definitions
	297	+ * preprocessor definitions for the bitfield rdm_desc_init_i.
	298	+ * port="pif_rdm_desc_init_i"
	299	+ */
	300	+
	301	+/* register address for bitfield rdm_desc_init_i */
	302	+#define HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_ADR 0x00005a00
	303	+/* bitmask for bitfield rdm_desc_init_i */
	304	+#define HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_MSK 0xffffffff
	305	+/* inverted bitmask for bitfield rdm_desc_init_i */
	306	+#define HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_MSKN 0x00000000
	307	+/* lower bit position of bitfield rdm_desc_init_i */
	308	+#define HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_SHIFT 0
	309	+/* width of bitfield rdm_desc_init_i */
	310	+#define HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_WIDTH 32
	311	+/* default value of bitfield rdm_desc_init_i */
	312	+#define HW_ATL_RDM_RX_DMA_DESC_CACHE_INIT_DEFAULT 0x0
	313	+
296	314	/* rx int_desc_wrb_en bitfield definitions
297	315	* preprocessor definitions for the bitfield "int_desc_wrb_en".
298	316	* port="pif_rdm_int_desc_wrb_en_i"

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils_fw2x.c+21−0

@@ -30,6 +30,8 @@ · 29 unmodified lines
30	30	#define HW_ATL_FW2X_MPI_STATE_ADDR 0x370
31	31	#define HW_ATL_FW2X_MPI_STATE2_ADDR 0x374
32	32
	33	+#define HW_ATL_FW2X_CAP_PAUSE BIT(CAPS_HI_PAUSE)
	34	+#define HW_ATL_FW2X_CAP_ASYM_PAUSE BIT(CAPS_HI_ASYMMETRIC_PAUSE)
33	35	#define HW_ATL_FW2X_CAP_SLEEP_PROXY BIT(CAPS_HI_SLEEP_PROXY)
34	36	#define HW_ATL_FW2X_CAP_WOL BIT(CAPS_HI_WOL)
35	37
@@ -451,6 +453,24 @@ static int aq_fw2x_set_flow_control(struct aq_hw_s *self) · 415 unmodified lines
451	453	return 0;
452	454	}
453	455
	456	+static u32 aq_fw2x_get_flow_control(struct aq_hw_s self, u32 fcmode)
	457	+{
	458	+ u32 mpi_state = aq_hw_read_reg(self, HW_ATL_FW2X_MPI_STATE2_ADDR);
	459	+
	460	+ if (mpi_state & HW_ATL_FW2X_CAP_PAUSE)
	461	+ if (mpi_state & HW_ATL_FW2X_CAP_ASYM_PAUSE)
	462	+ *fcmode = AQ_NIC_FC_RX;
	463	+ else
	464	+ *fcmode = AQ_NIC_FC_RX \| AQ_NIC_FC_TX;
	465	+ else
	466	+ if (mpi_state & HW_ATL_FW2X_CAP_ASYM_PAUSE)
	467	+ *fcmode = AQ_NIC_FC_TX;
	468	+ else
	469	+ *fcmode = 0;
	470	+
	471	+ return 0;
	472	+}
	473	+
454	474	const struct aq_fw_ops aq_fw_2x_ops = {
455	475	.init = aq_fw2x_init,
456	476	.deinit = aq_fw2x_deinit,
@@ -465,4 +485,5 @@ const struct aq_fw_ops aq_fw_2x_ops = { · 8 unmodified lines
465	485	.set_eee_rate = aq_fw2x_set_eee_rate,
466	486	.get_eee_rate = aq_fw2x_get_eee_rate,
467	487	.set_flow_control = aq_fw2x_set_flow_control,
	488	+ .get_flow_control = aq_fw2x_get_flow_control
468	489	};

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c+2−1

@@ -3760,7 +3760,8 @@ static int hns3_reset_notify_init_enet(struct hnae3_handle *handle) · 3759 unmodified lines
3760	3760	/* Hardware table is only clear when pf resets */
3761	3761	if (!(handle->flags & HNAE3_SUPPORT_VF)) {
3762	3762	ret = hns3_restore_vlan(netdev);
3763		− return ret;
	3763	+ if (ret)
	3764	+ return ret;
3764	3765	}
3765	3766
3766	3767	ret = hns3_restore_fd_rules(netdev);

drivers/net/ethernet/ibm/ibmvnic.c+1−1

@@ -1545,7 +1545,7 @@ static netdev_tx_t ibmvnic_xmit(struct sk_buff skb, struct net_device netdev) · 1544 unmodified lines
1545	1545	tx_crq.v1.sge_len = cpu_to_be32(skb->len);
1546	1546	tx_crq.v1.ioba = cpu_to_be64(data_dma_addr);
1547	1547
1548		− if (adapter->vlan_header_insertion) {
	1548	+ if (adapter->vlan_header_insertion && skb_vlan_tag_present(skb)) {
1549	1549	tx_crq.v1.flags2 \|= IBMVNIC_TX_VLAN_INSERT;
1550	1550	tx_crq.v1.vlan_id = cpu_to_be16(skb->vlan_tci);
1551	1551	}

drivers/net/ethernet/intel/i40e/i40e_main.c+5−3

@@ -12249,6 +12249,8 @@ static int i40e_config_netdev(struct i40e_vsi *vsi) · 12248 unmodified lines
12249	12249	NETIF_F_GSO_GRE \|
12250	12250	NETIF_F_GSO_GRE_CSUM \|
12251	12251	NETIF_F_GSO_PARTIAL \|
	12252	+ NETIF_F_GSO_IPXIP4 \|
	12253	+ NETIF_F_GSO_IPXIP6 \|
12252	12254	NETIF_F_GSO_UDP_TUNNEL \|
12253	12255	NETIF_F_GSO_UDP_TUNNEL_CSUM \|
12254	12256	NETIF_F_SCTP_CRC \|
@@ -12266,13 +12268,13 @@ static int i40e_config_netdev(struct i40e_vsi *vsi) · 11 unmodified lines
12266	12268	/* record features VLANs can make use of */
12267	12269	netdev->vlan_features \|= hw_enc_features \| NETIF_F_TSO_MANGLEID;
12268	12270
12269		− if (!(pf->flags & I40E_FLAG_MFP_ENABLED))
12270		− netdev->hw_features \|= NETIF_F_NTUPLE \| NETIF_F_HW_TC;
12271		−
12272	12271	hw_features = hw_enc_features \|
12273	12272	NETIF_F_HW_VLAN_CTAG_TX \|
12274	12273	NETIF_F_HW_VLAN_CTAG_RX;
12275	12274
	12275	+ if (!(pf->flags & I40E_FLAG_MFP_ENABLED))
	12276	+ hw_features \|= NETIF_F_NTUPLE \| NETIF_F_HW_TC;
	12277	+
12276	12278	netdev->hw_features \|= hw_features;
12277	12279
12278	12280	netdev->features \|= hw_features \| NETIF_F_HW_VLAN_CTAG_FILTER;

drivers/net/ethernet/intel/ice/ice.h+3−1

@@ -76,6 +76,8 @@ extern const char ice_drv_ver[]; · 75 unmodified lines
76	76	#define ICE_MIN_INTR_PER_VF (ICE_MIN_QS_PER_VF + 1)
77	77	#define ICE_DFLT_INTR_PER_VF (ICE_DFLT_QS_PER_VF + 1)
78	78
	79	+#define ICE_MAX_RESET_WAIT 20
	80	+
79	81	#define ICE_VSIQF_HKEY_ARRAY_SIZE ((VSIQF_HKEY_MAX_INDEX + 1) * 4)
80	82
81	83	#define ICE_DFLT_NETIF_M (NETIF_MSG_DRV \| NETIF_MSG_PROBE \| NETIF_MSG_LINK)
@@ -189,7 +191,6 @@ struct ice_vsi { · 107 unmodified lines
189	191	u64 tx_linearize;
190	192	DECLARE_BITMAP(state, __ICE_STATE_NBITS);
191	193	DECLARE_BITMAP(flags, ICE_VSI_FLAG_NBITS);
192		− unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
193	194	unsigned int current_netdev_flags;
194	195	u32 tx_restart;
195	196	u32 tx_busy;
@@ -369,5 +370,6 @@ int ice_set_rss(struct ice_vsi vsi, u8 seed, u8 *lut, u16 lut_size); · 173 unmodified lines
369	370	int ice_get_rss(struct ice_vsi vsi, u8 seed, u8 *lut, u16 lut_size);
370	371	void ice_fill_rss_lut(u8 *lut, u16 rss_table_size, u16 rss_size);
371	372	void ice_print_link_msg(struct ice_vsi *vsi, bool isup);
	373	+void ice_napi_del(struct ice_vsi *vsi);
372	374
373	375	#endif /* _ICE_H_ */

drivers/net/ethernet/intel/ice/ice_common.c+3−0

@@ -811,6 +811,9 @@ void ice_deinit_hw(struct ice_hw *hw) · 810 unmodified lines
811	811	/* Attempt to disable FW logging before shutting down control queues */
812	812	ice_cfg_fw_log(hw, false);
813	813	ice_shutdown_all_ctrlq(hw);
	814	+
	815	+ /* Clear VSI contexts if not already cleared */
	816	+ ice_clear_all_vsi_ctx(hw);
814	817	}
815	818
816	819	/**

drivers/net/ethernet/intel/ice/ice_ethtool.c+6−1

@@ -1517,10 +1517,15 @@ ice_set_pauseparam(struct net_device netdev, struct ethtool_pauseparam pause) · 1516 unmodified lines
1517	1517	}
1518	1518
1519	1519	if (!test_bit(__ICE_DOWN, pf->state)) {
1520		− /* Give it a little more time to try to come back */
	1520	+ /* Give it a little more time to try to come back. If still
	1521	+ * down, restart autoneg link or reinitialize the interface.
	1522	+ */
1521	1523	msleep(75);
1522	1524	if (!test_bit(__ICE_DOWN, pf->state))
1523	1525	return ice_nway_reset(netdev);
	1526	+
	1527	+ ice_down(vsi);
	1528	+ ice_up(vsi);
1524	1529	}
1525	1530
1526	1531	return err;

drivers/net/ethernet/intel/ice/ice_hw_autogen.h+2−0

@@ -242,6 +242,8 @@ · 241 unmodified lines
242	242	#define GLNVM_ULD 0x000B6008
243	243	#define GLNVM_ULD_CORER_DONE_M BIT(3)
244	244	#define GLNVM_ULD_GLOBR_DONE_M BIT(4)
	245	+#define GLPCI_CNF2 0x000BE004
	246	+#define GLPCI_CNF2_CACHELINE_SIZE_M BIT(1)
245	247	#define PF_FUNC_RID 0x0009E880
246	248	#define PF_FUNC_RID_FUNC_NUM_S 0
247	249	#define PF_FUNC_RID_FUNC_NUM_M ICE_M(0x7, 0)

drivers/net/ethernet/intel/ice/ice_lib.c+2−1

@@ -1997,7 +1997,7 @@ int ice_cfg_vlan_pruning(struct ice_vsi *vsi, bool ena) · 1996 unmodified lines
1997	1997	status = ice_update_vsi(&vsi->back->hw, vsi->idx, ctxt, NULL);
1998	1998	if (status) {
1999	1999	netdev_err(vsi->netdev, "%sabling VLAN pruning on VSI handle: %d, VSI HW ID: %d failed, err = %d, aq_err = %d\n",
2000		− ena ? "Ena" : "Dis", vsi->idx, vsi->vsi_num, status,
	2000	+ ena ? "En" : "Dis", vsi->idx, vsi->vsi_num, status,
2001	2001	vsi->back->hw.adminq.sq_last_status);
2002	2002	goto err_out;
2003	2003	}
@@ -2458,6 +2458,7 @@ int ice_vsi_release(struct ice_vsi *vsi) · 454 unmodified lines
2458	2458	* on this wq
2459	2459	*/
2460	2460	if (vsi->netdev && !ice_is_reset_in_progress(pf->state)) {
	2461	+ ice_napi_del(vsi);
2461	2462	unregister_netdev(vsi->netdev);
2462	2463	free_netdev(vsi->netdev);
2463	2464	vsi->netdev = NULL;

drivers/net/ethernet/intel/ice/ice_main.c+48−38

@@ -1465,7 +1465,7 @@ skip_req_irq: · 1464 unmodified lines
1465	1465	* ice_napi_del - Remove NAPI handler for the VSI
1466	1466	* @vsi: VSI for which NAPI handler is to be removed
1467	1467	*/
1468		−static void ice_napi_del(struct ice_vsi *vsi)
	1468	+void ice_napi_del(struct ice_vsi *vsi)
1469	1469	{
1470	1470	int v_idx;
1471	1471
@@ -1622,7 +1622,6 @@ static int ice_vlan_rx_add_vid(struct net_device *netdev, · 150 unmodified lines
1622	1622	{
1623	1623	struct ice_netdev_priv *np = netdev_priv(netdev);
1624	1624	struct ice_vsi *vsi = np->vsi;
1625		− int ret;
1626	1625
1627	1626	if (vid >= VLAN_N_VID) {
1628	1627	netdev_err(netdev, "VLAN id requested %d is out of range %d\n",
@@ -1635,7 +1634,8 @@ static int ice_vlan_rx_add_vid(struct net_device *netdev, · 6 unmodified lines
1635	1634
1636	1635	/* Enable VLAN pruning when VLAN 0 is added */
1637	1636	if (unlikely(!vid)) {
1638		− ret = ice_cfg_vlan_pruning(vsi, true);
	1637	+ int ret = ice_cfg_vlan_pruning(vsi, true);
	1638	+
1639	1639	if (ret)
1640	1640	return ret;
1641	1641	}
@@ -1644,12 +1644,7 @@ static int ice_vlan_rx_add_vid(struct net_device *netdev, · 2 unmodified lines
1644	1644	* needed to continue allowing all untagged packets since VLAN prune
1645	1645	* list is applied to all packets by the switch
1646	1646	*/
1647		− ret = ice_vsi_add_vlan(vsi, vid);
1648		−
1649		− if (!ret)
1650		− set_bit(vid, vsi->active_vlans);
1651		−
1652		− return ret;
	1647	+ return ice_vsi_add_vlan(vsi, vid);
1653	1648	}
1654	1649
1655	1650	/**
@@ -1677,8 +1672,6 @@ static int ice_vlan_rx_kill_vid(struct net_device *netdev, · 21 unmodified lines
1677	1672	if (status)
1678	1673	return status;
1679	1674
1680		− clear_bit(vid, vsi->active_vlans);
1681		−
1682	1675	/* Disable VLAN pruning when VLAN 0 is removed */
1683	1676	if (unlikely(!vid))
1684	1677	status = ice_cfg_vlan_pruning(vsi, false);
@@ -2001,6 +1994,22 @@ static int ice_init_interrupt_scheme(struct ice_pf *pf) · 316 unmodified lines
2001	1994	return 0;
2002	1995	}
2003	1996
	1997	+/**
	1998	+ * ice_verify_cacheline_size - verify driver's assumption of 64 Byte cache lines
	1999	+ * @pf: pointer to the PF structure
	2000	+ *
	2001	+ * There is no error returned here because the driver should be able to handle
	2002	+ * 128 Byte cache lines, so we only print a warning in case issues are seen,
	2003	+ * specifically with Tx.
	2004	+ */
	2005	+static void ice_verify_cacheline_size(struct ice_pf *pf)
	2006	+{
	2007	+ if (rd32(&pf->hw, GLPCI_CNF2) & GLPCI_CNF2_CACHELINE_SIZE_M)
	2008	+ dev_warn(&pf->pdev->dev,
	2009	+ "%d Byte cache line assumption is invalid, driver may have Tx timeouts!\n",
	2010	+ ICE_CACHE_LINE_BYTES);
	2011	+}
	2012	+
2004	2013	/**
2005	2014	* ice_probe - Device initialization routine
2006	2015	* @pdev: PCI device information struct
@@ -2151,6 +2160,8 @@ static int ice_probe(struct pci_dev *pdev, · 144 unmodified lines
2151	2160	/* since everything is good, start the service timer */
2152	2161	mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period));
2153	2162
	2163	+ ice_verify_cacheline_size(pf);
	2164	+
2154	2165	return 0;
2155	2166
2156	2167	err_alloc_sw_unroll:
@@ -2182,6 +2193,12 @@ static void ice_remove(struct pci_dev *pdev) · 25 unmodified lines
2182	2193	if (!pf)
2183	2194	return;
2184	2195
	2196	+ for (i = 0; i < ICE_MAX_RESET_WAIT; i++) {
	2197	+ if (!ice_is_reset_in_progress(pf->state))
	2198	+ break;
	2199	+ msleep(100);
	2200	+ }
	2201	+
2185	2202	set_bit(__ICE_DOWN, pf->state);
2186	2203	ice_service_task_stop(pf);
2187	2204
@@ -2509,31 +2526,6 @@ static int ice_vsi_vlan_setup(struct ice_vsi *vsi) · 321 unmodified lines
2509	2526	return ret;
2510	2527	}
2511	2528
2512		−/**
2513		− * ice_restore_vlan - Reinstate VLANs when vsi/netdev comes back up
2514		− * @vsi: the VSI being brought back up
2515		− */
2516		−static int ice_restore_vlan(struct ice_vsi *vsi)
2517		−{
2518		− int err;
2519		− u16 vid;
2520		−
2521		− if (!vsi->netdev)
2522		− return -EINVAL;
2523		−
2524		− err = ice_vsi_vlan_setup(vsi);
2525		− if (err)
2526		− return err;
2527		−
2528		− for_each_set_bit(vid, vsi->active_vlans, VLAN_N_VID) {
2529		− err = ice_vlan_rx_add_vid(vsi->netdev, htons(ETH_P_8021Q), vid);
2530		− if (err)
2531		− break;
2532		− }
2533		−
2534		− return err;
2535		−}
2536		−
2537	2529	/**
2538	2530	* ice_vsi_cfg - Setup the VSI
2539	2531	* @vsi: the VSI being configured
@@ -2546,7 +2538,9 @@ static int ice_vsi_cfg(struct ice_vsi *vsi) · 6 unmodified lines
2546	2538
2547	2539	if (vsi->netdev) {
2548	2540	ice_set_rx_mode(vsi->netdev);
2549		− err = ice_restore_vlan(vsi);
	2541	+
	2542	+ err = ice_vsi_vlan_setup(vsi);
	2543	+
2550	2544	if (err)
2551	2545	return err;
2552	2546	}
@@ -3296,7 +3290,7 @@ static void ice_rebuild(struct ice_pf *pf) · 743 unmodified lines
3296	3290	struct device *dev = &pf->pdev->dev;
3297	3291	struct ice_hw *hw = &pf->hw;
3298	3292	enum ice_status ret;
3299		− int err;
	3293	+ int err, i;
3300	3294
3301	3295	if (test_bit(__ICE_DOWN, pf->state))
3302	3296	goto clear_recovery;
@@ -3370,6 +3364,22 @@ static void ice_rebuild(struct ice_pf *pf) · 67 unmodified lines
3370	3364	}
3371	3365
3372	3366	ice_reset_all_vfs(pf, true);
	3367	+
	3368	+ for (i = 0; i < pf->num_alloc_vsi; i++) {
	3369	+ bool link_up;
	3370	+
	3371	+ if (!pf->vsi[i] \|\| pf->vsi[i]->type != ICE_VSI_PF)
	3372	+ continue;
	3373	+ ice_get_link_status(pf->vsi[i]->port_info, &link_up);
	3374	+ if (link_up) {
	3375	+ netif_carrier_on(pf->vsi[i]->netdev);
	3376	+ netif_tx_wake_all_queues(pf->vsi[i]->netdev);
	3377	+ } else {
	3378	+ netif_carrier_off(pf->vsi[i]->netdev);
	3379	+ netif_tx_stop_all_queues(pf->vsi[i]->netdev);
	3380	+ }
	3381	+ }
	3382	+
3373	3383	/* if we get here, reset flow is successful */
3374	3384	clear_bit(__ICE_RESET_FAILED, pf->state);
3375	3385	return;

drivers/net/ethernet/intel/ice/ice_switch.c+12−0

@@ -347,6 +347,18 @@ static void ice_clear_vsi_ctx(struct ice_hw *hw, u16 vsi_handle) · 346 unmodified lines
347	347	}
348	348	}
349	349
	350	+/**
	351	+ * ice_clear_all_vsi_ctx - clear all the VSI context entries
	352	+ * @hw: pointer to the hw struct
	353	+ */
	354	+void ice_clear_all_vsi_ctx(struct ice_hw *hw)
	355	+{
	356	+ u16 i;
	357	+
	358	+ for (i = 0; i < ICE_MAX_VSI; i++)
	359	+ ice_clear_vsi_ctx(hw, i);
	360	+}
	361	+
350	362	/**
351	363	* ice_add_vsi - add VSI context to the hardware and VSI handle list
352	364	* @hw: pointer to the hw struct

drivers/net/ethernet/intel/ice/ice_switch.h+2−0

@@ -190,6 +190,8 @@ ice_update_vsi(struct ice_hw hw, u16 vsi_handle, struct ice_vsi_ctx vsi_ctx, · 189 unmodified lines
190	190	struct ice_sq_cd *cd);
191	191	bool ice_is_vsi_valid(struct ice_hw *hw, u16 vsi_handle);
192	192	struct ice_vsi_ctx ice_get_vsi_ctx(struct ice_hw hw, u16 vsi_handle);
	193	+void ice_clear_all_vsi_ctx(struct ice_hw *hw);
	194	+/* Switch config */
193	195	enum ice_status ice_get_initial_sw_cfg(struct ice_hw *hw);
194	196
195	197	/* Switch/bridge related commands */

drivers/net/ethernet/intel/ice/ice_txrx.c+6−5

@@ -1520,7 +1520,7 @@ int ice_tso(struct ice_tx_buf first, struct ice_tx_offload_params off) · 1519 unmodified lines
1520	1520
1521	1521	/* update gso_segs and bytecount */
1522	1522	first->gso_segs = skb_shinfo(skb)->gso_segs;
1523		− first->bytecount = (first->gso_segs - 1) * off->header_len;
	1523	+ first->bytecount += (first->gso_segs - 1) * off->header_len;
1524	1524
1525	1525	cd_tso_len = skb->len - off->header_len;
1526	1526	cd_mss = skb_shinfo(skb)->gso_size;
@@ -1556,15 +1556,15 @@ int ice_tso(struct ice_tx_buf first, struct ice_tx_offload_params off) · 29 unmodified lines
1556	1556	* magnitude greater than our largest possible GSO size.
1557	1557	*
1558	1558	* This would then be implemented as:
1559		− * return (((size >> 12) * 85) >> 8) + 1;
	1559	+ * return (((size >> 12) * 85) >> 8) + ICE_DESCS_FOR_SKB_DATA_PTR;
1560	1560	*
1561	1561	* Since multiplication and division are commutative, we can reorder
1562	1562	* operations into:
1563		− * return ((size * 85) >> 20) + 1;
	1563	+ * return ((size * 85) >> 20) + ICE_DESCS_FOR_SKB_DATA_PTR;
1564	1564	*/
1565	1565	static unsigned int ice_txd_use_count(unsigned int size)
1566	1566	{
1567		− return ((size * 85) >> 20) + 1;
	1567	+ return ((size * 85) >> 20) + ICE_DESCS_FOR_SKB_DATA_PTR;
1568	1568	}
1569	1569
1570	1570	/**
@@ -1706,7 +1706,8 @@ ice_xmit_frame_ring(struct sk_buff skb, struct ice_ring tx_ring) · 135 unmodified lines
1706	1706	* + 1 desc for context descriptor,
1707	1707	* otherwise try next time
1708	1708	*/
1709		− if (ice_maybe_stop_tx(tx_ring, count + 4 + 1)) {
	1709	+ if (ice_maybe_stop_tx(tx_ring, count + ICE_DESCS_PER_CACHE_LINE +
	1710	+ ICE_DESCS_FOR_CTX_DESC)) {
1710	1711	tx_ring->tx_stats.tx_busy++;
1711	1712	return NETDEV_TX_BUSY;
1712	1713	}

drivers/net/ethernet/intel/ice/ice_txrx.h+15−2

@@ -22,8 +22,21 @@ · 21 unmodified lines
22	22	#define ICE_RX_BUF_WRITE 16 /* Must be power of 2 */
23	23	#define ICE_MAX_TXQ_PER_TXQG 128
24	24
25		−/* Tx Descriptors needed, worst case */
26		−#define DESC_NEEDED (MAX_SKB_FRAGS + 4)
	25	+/* We are assuming that the cache line is always 64 Bytes here for ice.
	26	+ * In order to make sure that is a correct assumption there is a check in probe
	27	+ * to print a warning if the read from GLPCI_CNF2 tells us that the cache line
	28	+ * size is 128 bytes. We do it this way because we do not want to read the
	29	+ * GLPCI_CNF2 register or a variable containing the value on every pass through
	30	+ * the Tx path.
	31	+ */
	32	+#define ICE_CACHE_LINE_BYTES 64
	33	+#define ICE_DESCS_PER_CACHE_LINE (ICE_CACHE_LINE_BYTES / \
	34	+ sizeof(struct ice_tx_desc))
	35	+#define ICE_DESCS_FOR_CTX_DESC 1
	36	+#define ICE_DESCS_FOR_SKB_DATA_PTR 1
	37	+/* Tx descriptors needed, worst case */
	38	+#define DESC_NEEDED (MAX_SKB_FRAGS + ICE_DESCS_FOR_CTX_DESC + \
	39	+ ICE_DESCS_PER_CACHE_LINE + ICE_DESCS_FOR_SKB_DATA_PTR)
27	40	#define ICE_DESC_UNUSED(R) \
28	41	((((R)->next_to_clean > (R)->next_to_use) ? 0 : (R)->count) + \
29	42	(R)->next_to_clean - (R)->next_to_use - 1)

drivers/net/ethernet/intel/ice/ice_type.h+1−1

@@ -92,12 +92,12 @@ struct ice_link_status { · 91 unmodified lines
92	92	u64 phy_type_low;
93	93	u16 max_frame_size;
94	94	u16 link_speed;
	95	+ u16 req_speeds;
95	96	u8 lse_ena; /* Link Status Event notification */
96	97	u8 link_info;
97	98	u8 an_info;
98	99	u8 ext_info;
99	100	u8 pacing;
100		− u8 req_speeds;
101	101	/* Refer to #define from module_type[ICE_MODULE_TYPE_TOTAL_BYTE] of
102	102	* ice_aqc_get_phy_caps structure
103	103	*/

drivers/net/ethernet/intel/ice/ice_virtchnl_pf.c+1−3

@@ -348,7 +348,7 @@ static int ice_vsi_set_pvid(struct ice_vsi *vsi, u16 vid) · 347 unmodified lines
348	348	struct ice_vsi_ctx ctxt = { 0 };
349	349	enum ice_status status;
350	350
351		− ctxt.info.vlan_flags = ICE_AQ_VSI_VLAN_MODE_TAGGED \|
	351	+ ctxt.info.vlan_flags = ICE_AQ_VSI_VLAN_MODE_UNTAGGED \|
352	352	ICE_AQ_VSI_PVLAN_INSERT_PVID \|
353	353	ICE_AQ_VSI_VLAN_EMOD_STR;
354	354	ctxt.info.pvid = cpu_to_le16(vid);
@@ -2171,7 +2171,6 @@ static int ice_vc_process_vlan_msg(struct ice_vf vf, u8 msg, bool add_v) · 1816 unmodified lines
2171	2171
2172	2172	if (!ice_vsi_add_vlan(vsi, vid)) {
2173	2173	vf->num_vlan++;
2174		− set_bit(vid, vsi->active_vlans);
2175	2174
2176	2175	/* Enable VLAN pruning when VLAN 0 is added */
2177	2176	if (unlikely(!vid))
@@ -2190,7 +2189,6 @@ static int ice_vc_process_vlan_msg(struct ice_vf vf, u8 msg, bool add_v) · 12 unmodified lines
2190	2189	*/
2191	2190	if (!ice_vsi_kill_vlan(vsi, vid)) {
2192	2191	vf->num_vlan--;
2193		− clear_bit(vid, vsi->active_vlans);
2194	2192
2195	2193	/* Disable VLAN pruning when removing VLAN 0 */
2196	2194	if (unlikely(!vid))

drivers/net/ethernet/intel/igb/igb_ptp.c+7−5

@@ -53,13 +53,15 @@ · 52 unmodified lines
53	53	* 2^40 * 10^-9 / 60 = 18.3 minutes.
54	54	*
55	55	* SYSTIM is converted to real time using a timecounter. As
56		− * timecounter_cyc2time() allows old timestamps, the timecounter
57		− * needs to be updated at least once per half of the SYSTIM interval.
58		− * Scheduling of delayed work is not very accurate, so we aim for 8
59		− * minutes to be sure the actual interval is shorter than 9.16 minutes.
	56	+ * timecounter_cyc2time() allows old timestamps, the timecounter needs
	57	+ * to be updated at least once per half of the SYSTIM interval.
	58	+ * Scheduling of delayed work is not very accurate, and also the NIC
	59	+ * clock can be adjusted to run up to 6% faster and the system clock
	60	+ * up to 10% slower, so we aim for 6 minutes to be sure the actual
	61	+ * interval in the NIC time is shorter than 9.16 minutes.
60	62	*/
61	63
62		−#define IGB_SYSTIM_OVERFLOW_PERIOD (HZ * 60 * 8)
	64	+#define IGB_SYSTIM_OVERFLOW_PERIOD (HZ * 60 * 6)
63	65	#define IGB_PTP_TX_TIMEOUT (HZ * 15)
64	66	#define INCPERIOD_82576 BIT(E1000_TIMINCA_16NS_SHIFT)
65	67	#define INCVALUE_82576_MASK GENMASK(E1000_TIMINCA_16NS_SHIFT - 1, 0)

drivers/net/ethernet/marvell/mvneta.c+2−2

@@ -494,7 +494,7 @@ struct mvneta_port { · 493 unmodified lines
494	494	#if defined(__LITTLE_ENDIAN)
495	495	struct mvneta_tx_desc {
496	496	u32 command; /* Options used by HW for packet transmitting.*/
497		− u16 reserverd1; /* csum_l4 (for future use) */
	497	+ u16 reserved1; /* csum_l4 (for future use) */
498	498	u16 data_size; /* Data size of transmitted packet in bytes */
499	499	u32 buf_phys_addr; /* Physical addr of transmitted buffer */
500	500	u32 reserved2; /* hw_cmd - (for future use, PMT) */
@@ -519,7 +519,7 @@ struct mvneta_rx_desc { · 18 unmodified lines
519	519	#else
520	520	struct mvneta_tx_desc {
521	521	u16 data_size; /* Data size of transmitted packet in bytes */
522		− u16 reserverd1; /* csum_l4 (for future use) */
	522	+ u16 reserved1; /* csum_l4 (for future use) */
523	523	u32 command; /* Options used by HW for packet transmitting.*/
524	524	u32 reserved2; /* hw_cmd - (for future use, PMT) */
525	525	u32 buf_phys_addr; /* Physical addr of transmitted buffer */

drivers/net/ethernet/qlogic/qed/qed_fcoe.c+8−3

@@ -147,7 +147,8 @@ qed_sp_fcoe_func_start(struct qed_hwfn *p_hwfn, · 146 unmodified lines
147	147	"Cannot satisfy CQ amount. CQs requested %d, CQs available %d. Aborting function start\n",
148	148	fcoe_pf_params->num_cqs,
149	149	p_hwfn->hw_info.feat_num[QED_FCOE_CQ]);
150		− return -EINVAL;
	150	+ rc = -EINVAL;
	151	+ goto err;
151	152	}
152	153
153	154	p_data->mtu = cpu_to_le16(fcoe_pf_params->mtu);
@@ -156,14 +157,14 @@ qed_sp_fcoe_func_start(struct qed_hwfn *p_hwfn, · 2 unmodified lines
156	157
157	158	rc = qed_cxt_acquire_cid(p_hwfn, PROTOCOLID_FCOE, &dummy_cid);
158	159	if (rc)
159		− return rc;
	160	+ goto err;
160	161
161	162	cxt_info.iid = dummy_cid;
162	163	rc = qed_cxt_get_cid_info(p_hwfn, &cxt_info);
163	164	if (rc) {
164	165	DP_NOTICE(p_hwfn, "Cannot find context info for dummy cid=%d\n",
165	166	dummy_cid);
166		− return rc;
	167	+ goto err;
167	168	}
168	169	p_cxt = cxt_info.p_cxt;
169	170	SET_FIELD(p_cxt->tstorm_ag_context.flags3,
@@ -240,6 +241,10 @@ qed_sp_fcoe_func_start(struct qed_hwfn *p_hwfn, · 70 unmodified lines
240	241	rc = qed_spq_post(p_hwfn, p_ent, NULL);
241	242
242	243	return rc;
	244	+
	245	+err:
	246	+ qed_sp_destroy_request(p_hwfn, p_ent);
	247	+ return rc;
243	248	}
244	249
245	250	static int

drivers/net/ethernet/qlogic/qed/qed_iscsi.c+1−0

@@ -200,6 +200,7 @@ qed_sp_iscsi_func_start(struct qed_hwfn *p_hwfn, · 199 unmodified lines
200	200	"Cannot satisfy CQ amount. Queues requested %d, CQs available %d. Aborting function start\n",
201	201	p_params->num_queues,
202	202	p_hwfn->hw_info.feat_num[QED_ISCSI_CQ]);
	203	+ qed_sp_destroy_request(p_hwfn, p_ent);
203	204	return -EINVAL;
204	205	}
205	206

drivers/net/ethernet/qlogic/qed/qed_l2.c+8−4

@@ -740,8 +740,7 @@ int qed_sp_vport_update(struct qed_hwfn *p_hwfn, · 739 unmodified lines
740	740
741	741	rc = qed_sp_vport_update_rss(p_hwfn, p_ramrod, p_rss_params);
742	742	if (rc) {
743		− /* Return spq entry which is taken in qed_sp_init_request()*/
744		− qed_spq_return_entry(p_hwfn, p_ent);
	743	+ qed_sp_destroy_request(p_hwfn, p_ent);
745	744	return rc;
746	745	}
747	746
@@ -1355,6 +1354,7 @@ qed_filter_ucast_common(struct qed_hwfn *p_hwfn, · 607 unmodified lines
1355	1354	DP_NOTICE(p_hwfn,
1356	1355	"%d is not supported yet\n",
1357	1356	p_filter_cmd->opcode);
	1357	+ qed_sp_destroy_request(p_hwfn, *pp_ent);
1358	1358	return -EINVAL;
1359	1359	}
1360	1360
@@ -2056,13 +2056,13 @@ qed_configure_rfs_ntuple_filter(struct qed_hwfn *p_hwfn, · 695 unmodified lines
2056	2056	} else {
2057	2057	rc = qed_fw_vport(p_hwfn, p_params->vport_id, &abs_vport_id);
2058	2058	if (rc)
2059		− return rc;
	2059	+ goto err;
2060	2060
2061	2061	if (p_params->qid != QED_RFS_NTUPLE_QID_RSS) {
2062	2062	rc = qed_fw_l2_queue(p_hwfn, p_params->qid,
2063	2063	&abs_rx_q_id);
2064	2064	if (rc)
2065		− return rc;
	2065	+ goto err;
2066	2066
2067	2067	p_ramrod->rx_qid_valid = 1;
2068	2068	p_ramrod->rx_qid = cpu_to_le16(abs_rx_q_id);
@@ -2083,6 +2083,10 @@ qed_configure_rfs_ntuple_filter(struct qed_hwfn *p_hwfn, · 14 unmodified lines
2083	2083	(u64)p_params->addr, p_params->length);
2084	2084
2085	2085	return qed_spq_post(p_hwfn, p_ent, NULL);
	2086	+
	2087	+err:
	2088	+ qed_sp_destroy_request(p_hwfn, p_ent);
	2089	+ return rc;
2086	2090	}
2087	2091
2088	2092	int qed_get_rxq_coalesce(struct qed_hwfn *p_hwfn,

drivers/net/ethernet/qlogic/qed/qed_rdma.c+1−0

@@ -1514,6 +1514,7 @@ qed_rdma_register_tid(void *rdma_cxt, · 1513 unmodified lines
1514	1514	default:
1515	1515	rc = -EINVAL;
1516	1516	DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "rc = %d\n", rc);
	1517	+ qed_sp_destroy_request(p_hwfn, p_ent);
1517	1518	return rc;
1518	1519	}
1519	1520	SET_FIELD(p_ramrod->flags1,

drivers/net/ethernet/qlogic/qed/qed_roce.c+1−0

@@ -745,6 +745,7 @@ static int qed_roce_sp_destroy_qp_responder(struct qed_hwfn *p_hwfn, · 744 unmodified lines
745	745	DP_NOTICE(p_hwfn,
746	746	"qed destroy responder failed: cannot allocate memory (ramrod). rc = %d\n",
747	747	rc);
	748	+ qed_sp_destroy_request(p_hwfn, p_ent);
748	749	return rc;
749	750	}
750	751

drivers/net/ethernet/qlogic/qed/qed_sp.h+14−0

@@ -167,6 +167,9 @@ struct qed_spq_entry { · 166 unmodified lines
167	167	enum spq_mode comp_mode;
168	168	struct qed_spq_comp_cb comp_cb;
169	169	struct qed_spq_comp_done comp_done; /* SPQ_MODE_EBLOCK */
	170	+
	171	+ /* Posted entry for unlimited list entry in EBLOCK mode */
	172	+ struct qed_spq_entry *post_ent;
170	173	};
171	174
172	175	struct qed_eq {
@@ -396,6 +399,17 @@ struct qed_sp_init_data { · 223 unmodified lines
396	399	struct qed_spq_comp_cb *p_comp_data;
397	400	};
398	401
	402	+/**
	403	+ * @brief Returns a SPQ entry to the pool / frees the entry if allocated.
	404	+ * Should be called on in error flows after initializing the SPQ entry
	405	+ * and before posting it.
	406	+ *
	407	+ * @param p_hwfn
	408	+ * @param p_ent
	409	+ */
	410	+void qed_sp_destroy_request(struct qed_hwfn *p_hwfn,
	411	+ struct qed_spq_entry *p_ent);
	412	+
399	413	int qed_sp_init_request(struct qed_hwfn *p_hwfn,
400	414	struct qed_spq_entry **pp_ent,
401	415	u8 cmd,

drivers/net/ethernet/qlogic/qed/qed_sp_commands.c+20−2

@@ -47,6 +47,19 @@ · 46 unmodified lines
47	47	#include "qed_sp.h"
48	48	#include "qed_sriov.h"
49	49
	50	+void qed_sp_destroy_request(struct qed_hwfn *p_hwfn,
	51	+ struct qed_spq_entry *p_ent)
	52	+{
	53	+ /* qed_spq_get_entry() can either get an entry from the free_pool,
	54	+ * or, if no entries are left, allocate a new entry and add it to
	55	+ * the unlimited_pending list.
	56	+ */
	57	+ if (p_ent->queue == &p_hwfn->p_spq->unlimited_pending)
	58	+ kfree(p_ent);
	59	+ else
	60	+ qed_spq_return_entry(p_hwfn, p_ent);
	61	+}
	62	+
50	63	int qed_sp_init_request(struct qed_hwfn *p_hwfn,
51	64	struct qed_spq_entry **pp_ent,
52	65	u8 cmd, u8 protocol, struct qed_sp_init_data *p_data)
@@ -80,7 +93,7 @@ int qed_sp_init_request(struct qed_hwfn *p_hwfn, · 27 unmodified lines
80	93
81	94	case QED_SPQ_MODE_BLOCK:
82	95	if (!p_data->p_comp_data)
83		− return -EINVAL;
	96	+ goto err;
84	97
85	98	p_ent->comp_cb.cookie = p_data->p_comp_data->cookie;
86	99	break;
@@ -95,7 +108,7 @@ int qed_sp_init_request(struct qed_hwfn *p_hwfn, · 8 unmodified lines
95	108	default:
96	109	DP_NOTICE(p_hwfn, "Unknown SPQE completion mode %d\n",
97	110	p_ent->comp_mode);
98		− return -EINVAL;
	111	+ goto err;
99	112	}
100	113
101	114	DP_VERBOSE(p_hwfn, QED_MSG_SPQ,
@@ -109,6 +122,11 @@ int qed_sp_init_request(struct qed_hwfn *p_hwfn, · 7 unmodified lines
109	122	memset(&p_ent->ramrod, 0, sizeof(p_ent->ramrod));
110	123
111	124	return 0;
	125	+
	126	+err:
	127	+ qed_sp_destroy_request(p_hwfn, p_ent);
	128	+
	129	+ return -EINVAL;
112	130	}
113	131
114	132	static enum tunnel_clss qed_tunn_clss_to_fw_clss(u8 type)

drivers/net/ethernet/qlogic/qed/qed_spq.c+35−34

@@ -142,6 +142,7 @@ static int qed_spq_block(struct qed_hwfn *p_hwfn, · 141 unmodified lines
142	142
143	143	DP_INFO(p_hwfn, "Ramrod is stuck, requesting MCP drain\n");
144	144	rc = qed_mcp_drain(p_hwfn, p_ptt);
	145	+ qed_ptt_release(p_hwfn, p_ptt);
145	146	if (rc) {
146	147	DP_NOTICE(p_hwfn, "MCP drain failed\n");
147	148	goto err;
@@ -150,18 +151,15 @@ static int qed_spq_block(struct qed_hwfn *p_hwfn, · 2 unmodified lines
150	151	/* Retry after drain */
151	152	rc = __qed_spq_block(p_hwfn, p_ent, p_fw_ret, true);
152	153	if (!rc)
153		− goto out;
	154	+ return 0;
154	155
155	156	comp_done = (struct qed_spq_comp_done *)p_ent->comp_cb.cookie;
156		− if (comp_done->done == 1)
	157	+ if (comp_done->done == 1) {
157	158	if (p_fw_ret)
158	159	*p_fw_ret = comp_done->fw_return_code;
159		−out:
160		− qed_ptt_release(p_hwfn, p_ptt);
161		− return 0;
162		−
	160	+ return 0;
	161	+ }
163	162	err:
164		− qed_ptt_release(p_hwfn, p_ptt);
165	163	DP_NOTICE(p_hwfn,
166	164	"Ramrod is stuck [CID %08x cmd %02x protocol %02x echo %04x]\n",
167	165	le32_to_cpu(p_ent->elem.hdr.cid),
@@ -685,6 +683,8 @@ static int qed_spq_add_entry(struct qed_hwfn *p_hwfn, · 517 unmodified lines
685	683	/* EBLOCK responsible to free the allocated p_ent */
686	684	if (p_ent->comp_mode != QED_SPQ_MODE_EBLOCK)
687	685	kfree(p_ent);
	686	+ else
	687	+ p_ent->post_ent = p_en2;
688	688
689	689	p_ent = p_en2;
690	690	}
@@ -767,6 +767,25 @@ static int qed_spq_pend_post(struct qed_hwfn *p_hwfn) · 76 unmodified lines
767	767	SPQ_HIGH_PRI_RESERVE_DEFAULT);
768	768	}
769	769
	770	+/* Avoid overriding of SPQ entries when getting out-of-order completions, by
	771	+ * marking the completions in a bitmap and increasing the chain consumer only
	772	+ * for the first successive completed entries.
	773	+ */
	774	+static void qed_spq_comp_bmap_update(struct qed_hwfn *p_hwfn, __le16 echo)
	775	+{
	776	+ u16 pos = le16_to_cpu(echo) % SPQ_RING_SIZE;
	777	+ struct qed_spq *p_spq = p_hwfn->p_spq;
	778	+
	779	+ __set_bit(pos, p_spq->p_comp_bitmap);
	780	+ while (test_bit(p_spq->comp_bitmap_idx,
	781	+ p_spq->p_comp_bitmap)) {
	782	+ __clear_bit(p_spq->comp_bitmap_idx,
	783	+ p_spq->p_comp_bitmap);
	784	+ p_spq->comp_bitmap_idx++;
	785	+ qed_chain_return_produced(&p_spq->chain);
	786	+ }
	787	+}
	788	+
770	789	int qed_spq_post(struct qed_hwfn *p_hwfn,
771	790	struct qed_spq_entry p_ent, u8 fw_return_code)
772	791	{
@@ -824,11 +843,12 @@ int qed_spq_post(struct qed_hwfn *p_hwfn, · 51 unmodified lines
824	843	p_ent->queue == &p_spq->unlimited_pending);
825	844
826	845	if (p_ent->queue == &p_spq->unlimited_pending) {
827		− /* This is an allocated p_ent which does not need to
828		− * return to pool.
829		− */
	846	+ struct qed_spq_entry *p_post_ent = p_ent->post_ent;
	847	+
830	848	kfree(p_ent);
831		− return rc;
	849	+
	850	+ /* Return the entry which was actually posted */
	851	+ p_ent = p_post_ent;
832	852	}
833	853
834	854	if (rc)
@@ -842,7 +862,7 @@ int qed_spq_post(struct qed_hwfn *p_hwfn, · 7 unmodified lines
842	862	spq_post_fail2:
843	863	spin_lock_bh(&p_spq->lock);
844	864	list_del(&p_ent->list);
845		− qed_chain_return_produced(&p_spq->chain);
	865	+ qed_spq_comp_bmap_update(p_hwfn, p_ent->elem.hdr.echo);
846	866
847	867	spq_post_fail:
848	868	/* return to the free pool */
@@ -874,25 +894,8 @@ int qed_spq_completion(struct qed_hwfn *p_hwfn, · 25 unmodified lines
874	894	spin_lock_bh(&p_spq->lock);
875	895	list_for_each_entry_safe(p_ent, tmp, &p_spq->completion_pending, list) {
876	896	if (p_ent->elem.hdr.echo == echo) {
877		− u16 pos = le16_to_cpu(echo) % SPQ_RING_SIZE;
878		−
879	897	list_del(&p_ent->list);
880		−
881		− /* Avoid overriding of SPQ entries when getting
882		− * out-of-order completions, by marking the completions
883		− * in a bitmap and increasing the chain consumer only
884		− * for the first successive completed entries.
885		− */
886		− __set_bit(pos, p_spq->p_comp_bitmap);
887		−
888		− while (test_bit(p_spq->comp_bitmap_idx,
889		− p_spq->p_comp_bitmap)) {
890		− __clear_bit(p_spq->comp_bitmap_idx,
891		− p_spq->p_comp_bitmap);
892		− p_spq->comp_bitmap_idx++;
893		− qed_chain_return_produced(&p_spq->chain);
894		− }
895		−
	898	+ qed_spq_comp_bmap_update(p_hwfn, echo);
896	899	p_spq->comp_count++;
897	900	found = p_ent;
898	901	break;
@@ -931,11 +934,9 @@ int qed_spq_completion(struct qed_hwfn *p_hwfn, · 32 unmodified lines
931	934	QED_MSG_SPQ,
932	935	"Got a completion without a callback function\n");
933	936
934		− if ((found->comp_mode != QED_SPQ_MODE_EBLOCK) \|\|
935		− (found->queue == &p_spq->unlimited_pending))
	937	+ if (found->comp_mode != QED_SPQ_MODE_EBLOCK)
936	938	/* EBLOCK is responsible for returning its own entry into the
937		− * free list, unless it originally added the entry into the
938		− * unlimited pending list.
	939	+ * free list.
939	940	*/
940	941	qed_spq_return_entry(p_hwfn, found);
941	942

drivers/net/ethernet/qlogic/qed/qed_sriov.c+1−0

@@ -101,6 +101,7 @@ static int qed_sp_vf_start(struct qed_hwfn p_hwfn, struct qed_vf_info p_vf) · 100 unmodified lines
101	101	default:
102	102	DP_NOTICE(p_hwfn, "Unknown VF personality %d\n",
103	103	p_hwfn->hw_info.personality);
	104	+ qed_sp_destroy_request(p_hwfn, p_ent);
104	105	return -EINVAL;
105	106	}
106	107

drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c+5−3

@@ -459,7 +459,7 @@ static int qlcnic_tx_pkt(struct qlcnic_adapter *adapter, · 458 unmodified lines
459	459	struct cmd_desc_type0 first_desc, struct sk_buff skb,
460	460	struct qlcnic_host_tx_ring *tx_ring)
461	461	{
462		− u8 l4proto, opcode = 0, hdr_len = 0;
	462	+ u8 l4proto, opcode = 0, hdr_len = 0, tag_vlan = 0;
463	463	u16 flags = 0, vlan_tci = 0;
464	464	int copied, offset, copy_len, size;
465	465	struct cmd_desc_type0 *hwdesc;
@@ -472,14 +472,16 @@ static int qlcnic_tx_pkt(struct qlcnic_adapter *adapter, · 6 unmodified lines
472	472	flags = QLCNIC_FLAGS_VLAN_TAGGED;
473	473	vlan_tci = ntohs(vh->h_vlan_TCI);
474	474	protocol = ntohs(vh->h_vlan_encapsulated_proto);
	475	+ tag_vlan = 1;
475	476	} else if (skb_vlan_tag_present(skb)) {
476	477	flags = QLCNIC_FLAGS_VLAN_OOB;
477	478	vlan_tci = skb_vlan_tag_get(skb);
	479	+ tag_vlan = 1;
478	480	}
479	481	if (unlikely(adapter->tx_pvid)) {
480		− if (vlan_tci && !(adapter->flags & QLCNIC_TAGGING_ENABLED))
	482	+ if (tag_vlan && !(adapter->flags & QLCNIC_TAGGING_ENABLED))
481	483	return -EIO;
482		− if (vlan_tci && (adapter->flags & QLCNIC_TAGGING_ENABLED))
	484	+ if (tag_vlan && (adapter->flags & QLCNIC_TAGGING_ENABLED))
483	485	goto set_flags;
484	486
485	487	flags = QLCNIC_FLAGS_VLAN_OOB;

drivers/net/ethernet/qualcomm/rmnet/rmnet_vnd.c+3−3

@@ -234,7 +234,7 @@ int rmnet_vnd_newlink(u8 id, struct net_device *rmnet_dev, · 233 unmodified lines
234	234	struct net_device *real_dev,
235	235	struct rmnet_endpoint *ep)
236	236	{
237		− struct rmnet_priv *priv;
	237	+ struct rmnet_priv *priv = netdev_priv(rmnet_dev);
238	238	int rc;
239	239
240	240	if (ep->egress_dev)
@@ -247,6 +247,8 @@ int rmnet_vnd_newlink(u8 id, struct net_device *rmnet_dev, · 6 unmodified lines
247	247	rmnet_dev->hw_features \|= NETIF_F_IP_CSUM \| NETIF_F_IPV6_CSUM;
248	248	rmnet_dev->hw_features \|= NETIF_F_SG;
249	249
	250	+ priv->real_dev = real_dev;
	251	+
250	252	rc = register_netdevice(rmnet_dev);
251	253	if (!rc) {
252	254	ep->egress_dev = rmnet_dev;
@@ -255,9 +257,7 @@ int rmnet_vnd_newlink(u8 id, struct net_device *rmnet_dev, · 2 unmodified lines
255	257
256	258	rmnet_dev->rtnl_link_ops = &rmnet_link_ops;
257	259
258		− priv = netdev_priv(rmnet_dev);
259	260	priv->mux_id = id;
260		− priv->real_dev = real_dev;
261	261
262	262	netdev_dbg(rmnet_dev, "rmnet dev created\n");
263	263	}

drivers/net/ethernet/stmicro/stmmac/common.h+2−1

@@ -365,7 +365,8 @@ struct dma_features { · 364 unmodified lines
365	365
366	366	/* GMAC TX FIFO is 8K, Rx FIFO is 16K */
367	367	#define BUF_SIZE_16KiB 16384
368		−#define BUF_SIZE_8KiB 8192
	368	+/* RX Buffer size must be < 8191 and multiple of 4/8/16 bytes */
	369	+#define BUF_SIZE_8KiB 8188
369	370	#define BUF_SIZE_4KiB 4096
370	371	#define BUF_SIZE_2KiB 2048
371	372

drivers/net/ethernet/stmicro/stmmac/descs_com.h+1−1

@@ -31,7 +31,7 @@ · 30 unmodified lines
31	31	/* Enhanced descriptors */
32	32	static inline void ehn_desc_rx_set_on_ring(struct dma_desc *p, int end)
33	33	{
34		− p->des1 \|= cpu_to_le32(((BUF_SIZE_8KiB - 1)
	34	+ p->des1 \|= cpu_to_le32((BUF_SIZE_8KiB
35	35	<< ERDES1_BUFFER2_SIZE_SHIFT)
36	36	& ERDES1_BUFFER2_SIZE_MASK);
37	37

drivers/net/ethernet/stmicro/stmmac/enh_desc.c+1−1

@@ -262,7 +262,7 @@ static void enh_desc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, · 261 unmodified lines
262	262	int mode, int end)
263	263	{
264	264	p->des0 \|= cpu_to_le32(RDES0_OWN);
265		− p->des1 \|= cpu_to_le32((BUF_SIZE_8KiB - 1) & ERDES1_BUFFER1_SIZE_MASK);
	265	+ p->des1 \|= cpu_to_le32(BUF_SIZE_8KiB & ERDES1_BUFFER1_SIZE_MASK);
266	266
267	267	if (mode == STMMAC_CHAIN_MODE)
268	268	ehn_desc_rx_set_on_chain(p);

drivers/net/ethernet/stmicro/stmmac/ring_mode.c+1−1

@@ -140,7 +140,7 @@ static void clean_desc3(void priv_ptr, struct dma_desc p) · 139 unmodified lines
140	140	static int set_16kib_bfsize(int mtu)
141	141	{
142	142	int ret = 0;
143		− if (unlikely(mtu >= BUF_SIZE_8KiB))
	143	+ if (unlikely(mtu > BUF_SIZE_8KiB))
144	144	ret = BUF_SIZE_16KiB;
145	145	return ret;
146	146	}

drivers/net/fddi/defza.c+4−3

@@ -1,4 +1,4 @@
1		−// SPDX-License-Identifier: GPL-2.0
	1	+// SPDX-License-Identifier: GPL-2.0+
2	2	/* FDDI network adapter driver for DEC FDDIcontroller 700/700-C devices.
3	3	*
4	4	* Copyright (c) 2018 Maciej W. Rozycki
@@ -56,7 +56,7 @@ · 51 unmodified lines
56	56	#define DRV_VERSION "v.1.1.4"
57	57	#define DRV_RELDATE "Oct 6 2018"
58	58
59		−static char version[] =
	59	+static const char version[] =
60	60	DRV_NAME ": " DRV_VERSION " " DRV_RELDATE " Maciej W. Rozycki\n";
61	61
62	62	MODULE_AUTHOR("Maciej W. Rozycki <macro@linux-mips.org>");
@@ -784,7 +784,7 @@ err_rx: · 721 unmodified lines
784	784	static void fza_tx_smt(struct net_device *dev)
785	785	{
786	786	struct fza_private *fp = netdev_priv(dev);
787		− struct fza_buffer_tx __iomem smt_tx_ptr, skb_data_ptr;
	787	+ struct fza_buffer_tx __iomem *smt_tx_ptr;
788	788	int i, len;
789	789	u32 own;
790	790
@@ -799,6 +799,7 @@ static void fza_tx_smt(struct net_device *dev) · 8 unmodified lines
799	799
800	800	if (!netif_queue_stopped(dev)) {
801	801	if (dev_nit_active(dev)) {
	802	+ struct fza_buffer_tx *skb_data_ptr;
802	803	struct sk_buff *skb;
803	804
804	805	/* Length must be a multiple of 4 as only word

drivers/net/fddi/defza.h+2−1

@@ -1,4 +1,4 @@
1		−/* SPDX-License-Identifier: GPL-2.0 */
	1	+/* SPDX-License-Identifier: GPL-2.0+ */
2	2	/* FDDI network adapter driver for DEC FDDIcontroller 700/700-C devices.
3	3	*
4	4	* Copyright (c) 2018 Maciej W. Rozycki
@@ -235,6 +235,7 @@ struct fza_ring_cmd { · 230 unmodified lines
235	235	#define FZA_RING_CMD 0x200400 /* command ring address */
236	236	#define FZA_RING_CMD_SIZE 0x40 /* command descriptor ring
237	237	* size
	238	+ */
238	239	/* Command constants. */
239	240	#define FZA_RING_CMD_MASK 0x7fffffff
240	241	#define FZA_RING_CMD_NOP 0x00000000 /* nop */

drivers/net/phy/broadcom.c+16−2

@@ -92,7 +92,7 @@ static int bcm54612e_config_init(struct phy_device *phydev) · 91 unmodified lines
92	92	return 0;
93	93	}
94	94
95		−static int bcm5481x_config(struct phy_device *phydev)
	95	+static int bcm54xx_config_clock_delay(struct phy_device *phydev)
96	96	{
97	97	int rc, val;
98	98
@@ -429,7 +429,7 @@ static int bcm5481_config_aneg(struct phy_device *phydev) · 330 unmodified lines
429	429	ret = genphy_config_aneg(phydev);
430	430
431	431	/* Then we can set up the delay. */
432		− bcm5481x_config(phydev);
	432	+ bcm54xx_config_clock_delay(phydev);
433	433
434	434	if (of_property_read_bool(np, "enet-phy-lane-swap")) {
435	435	/* Lane Swap - Undocumented register...magic! */
@@ -442,6 +442,19 @@ static int bcm5481_config_aneg(struct phy_device *phydev) · 6 unmodified lines
442	442	return ret;
443	443	}
444	444
	445	+static int bcm54616s_config_aneg(struct phy_device *phydev)
	446	+{
	447	+ int ret;
	448	+
	449	+ /* Aneg firsly. */
	450	+ ret = genphy_config_aneg(phydev);
	451	+
	452	+ /* Then we can set up the delay. */
	453	+ bcm54xx_config_clock_delay(phydev);
	454	+
	455	+ return ret;
	456	+}
	457	+
445	458	static int brcm_phy_setbits(struct phy_device *phydev, int reg, int set)
446	459	{
447	460	int val;
@@ -636,6 +649,7 @@ static struct phy_driver broadcom_drivers[] = { · 188 unmodified lines
636	649	.features = PHY_GBIT_FEATURES,
637	650	.flags = PHY_HAS_INTERRUPT,
638	651	.config_init = bcm54xx_config_init,
	652	+ .config_aneg = bcm54616s_config_aneg,
639	653	.ack_interrupt = bcm_phy_ack_intr,
640	654	.config_intr = bcm_phy_config_intr,
641	655	}, {

drivers/net/usb/smsc95xx.c+2−0

@@ -1321,6 +1321,8 @@ static int smsc95xx_bind(struct usbnet dev, struct usb_interface intf) · 1320 unmodified lines
1321	1321	dev->net->ethtool_ops = &smsc95xx_ethtool_ops;
1322	1322	dev->net->flags \|= IFF_MULTICAST;
1323	1323	dev->net->hard_header_len += SMSC95XX_TX_OVERHEAD_CSUM;
	1324	+ dev->net->min_mtu = ETH_MIN_MTU;
	1325	+ dev->net->max_mtu = ETH_DATA_LEN;
1324	1326	dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
1325	1327
1326	1328	pdata->dev = dev;

net/core/flow_dissector.c+2−2

@@ -1166,8 +1166,8 @@ ip_proto_again: · 1165 unmodified lines
1166	1166	break;
1167	1167	}
1168	1168
1169		− if (dissector_uses_key(flow_dissector,
1170		− FLOW_DISSECTOR_KEY_PORTS)) {
	1169	+ if (dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_PORTS) &&
	1170	+ !(key_control->flags & FLOW_DIS_IS_FRAGMENT)) {
1171	1171	key_ports = skb_flow_dissector_target(flow_dissector,
1172	1172	FLOW_DISSECTOR_KEY_PORTS,
1173	1173	target_container);

net/ipv4/inet_fragment.c+15−14

@@ -178,21 +178,22 @@ static struct inet_frag_queue inet_frag_alloc(struct netns_frags nf, · 177 unmodified lines
178	178	}
179	179
180	180	static struct inet_frag_queue inet_frag_create(struct netns_frags nf,
181		− void *arg)
	181	+ void *arg,
	182	+ struct inet_frag_queue **prev)
182	183	{
183	184	struct inet_frags *f = nf->f;
184	185	struct inet_frag_queue *q;
185		− int err;
186	186
187	187	q = inet_frag_alloc(nf, f, arg);
188		− if (!q)
	188	+ if (!q) {
	189	+ *prev = ERR_PTR(-ENOMEM);
189	190	return NULL;
190		−
	191	+ }
191	192	mod_timer(&q->timer, jiffies + nf->timeout);
192	193
193		− err = rhashtable_insert_fast(&nf->rhashtable, &q->node,
194		− f->rhash_params);
195		− if (err < 0) {
	194	+ *prev = rhashtable_lookup_get_insert_key(&nf->rhashtable, &q->key,
	195	+ &q->node, f->rhash_params);
	196	+ if (*prev) {
196	197	q->flags \|= INET_FRAG_COMPLETE;
197	198	inet_frag_kill(q);
198	199	inet_frag_destroy(q);
@@ -204,22 +205,22 @@ static struct inet_frag_queue inet_frag_create(struct netns_frags nf, · 5 unmodified lines
204	205	/* TODO : call from rcu_read_lock() and no longer use refcount_inc_not_zero() */
205	206	struct inet_frag_queue inet_frag_find(struct netns_frags nf, void *key)
206	207	{
207		− struct inet_frag_queue *fq;
	208	+ struct inet_frag_queue fq = NULL, prev;
208	209
209	210	if (!nf->high_thresh \|\| frag_mem_limit(nf) > nf->high_thresh)
210	211	return NULL;
211	212
212	213	rcu_read_lock();
213	214
214		− fq = rhashtable_lookup(&nf->rhashtable, key, nf->f->rhash_params);
215		− if (fq) {
	215	+ prev = rhashtable_lookup(&nf->rhashtable, key, nf->f->rhash_params);
	216	+ if (!prev)
	217	+ fq = inet_frag_create(nf, key, &prev);
	218	+ if (prev && !IS_ERR(prev)) {
	219	+ fq = prev;
216	220	if (!refcount_inc_not_zero(&fq->refcnt))
217	221	fq = NULL;
218		− rcu_read_unlock();
219		− return fq;
220	222	}
221	223	rcu_read_unlock();
222		−
223		− return inet_frag_create(nf, key);
	224	+ return fq;
224	225	}
225	226	EXPORT_SYMBOL(inet_frag_find);

net/sched/act_mirred.c+2−1

@@ -258,7 +258,8 @@ static int tcf_mirred_act(struct sk_buff skb, const struct tc_action a, · 257 unmodified lines
258	258	if (is_redirect) {
259	259	skb2->tc_redirected = 1;
260	260	skb2->tc_from_ingress = skb2->tc_at_ingress;
261		−
	261	+ if (skb2->tc_from_ingress)
	262	+ skb2->tstamp = 0;
262	263	/* let's the caller reinsert the packet, if possible */
263	264	if (use_reinsert) {
264	265	res->ingress = want_ingress;

net/sched/cls_flower.c+13−1

@@ -709,11 +709,23 @@ static int fl_set_enc_opt(struct nlattr *tb, struct fl_flow_key key, · 708 unmodified lines
709	709	struct netlink_ext_ack *extack)
710	710	{
711	711	const struct nlattr nla_enc_key, nla_opt_key, *nla_opt_msk = NULL;
712		− int option_len, key_depth, msk_depth = 0;
	712	+ int err, option_len, key_depth, msk_depth = 0;
	713	+
	714	+ err = nla_validate_nested(tb[TCA_FLOWER_KEY_ENC_OPTS],
	715	+ TCA_FLOWER_KEY_ENC_OPTS_MAX,
	716	+ enc_opts_policy, extack);
	717	+ if (err)
	718	+ return err;
713	719
714	720	nla_enc_key = nla_data(tb[TCA_FLOWER_KEY_ENC_OPTS]);
715	721
716	722	if (tb[TCA_FLOWER_KEY_ENC_OPTS_MASK]) {
	723	+ err = nla_validate_nested(tb[TCA_FLOWER_KEY_ENC_OPTS_MASK],
	724	+ TCA_FLOWER_KEY_ENC_OPTS_MAX,
	725	+ enc_opts_policy, extack);
	726	+ if (err)
	727	+ return err;
	728	+
717	729	nla_opt_msk = nla_data(tb[TCA_FLOWER_KEY_ENC_OPTS_MASK]);
718	730	msk_depth = nla_len(tb[TCA_FLOWER_KEY_ENC_OPTS_MASK]);
719	731	}

net/sched/sch_netem.c+0−9

@@ -648,15 +648,6 @@ deliver: · 647 unmodified lines
648	648	*/
649	649	skb->dev = qdisc_dev(sch);
650	650
651		−#ifdef CONFIG_NET_CLS_ACT
652		− /*
653		− * If it's at ingress let's pretend the delay is
654		− * from the network (tstamp will be updated).
655		− */
656		− if (skb->tc_redirected && skb->tc_from_ingress)
657		− skb->tstamp = 0;
658		−#endif
659		−
660	651	if (q->slot.slot_next) {
661	652	q->slot.packets_left--;
662	653	q->slot.bytes_left -= qdisc_pkt_len(skb);

net/tipc/link.c+7−4

@@ -1594,14 +1594,17 @@ static int tipc_link_proto_rcv(struct tipc_link l, struct sk_buff skb, · 1593 unmodified lines
1594	1594	if (in_range(peers_prio, l->priority + 1, TIPC_MAX_LINK_PRI))
1595	1595	l->priority = peers_prio;
1596	1596
1597		− /* ACTIVATE_MSG serves as PEER_RESET if link is already down */
1598		− if (msg_peer_stopping(hdr))
	1597	+ /* If peer is going down we want full re-establish cycle */
	1598	+ if (msg_peer_stopping(hdr)) {
1599	1599	rc = tipc_link_fsm_evt(l, LINK_FAILURE_EVT);
1600		− else if ((mtyp == RESET_MSG) \|\| !link_is_up(l))
	1600	+ break;
	1601	+ }
	1602	+ /* ACTIVATE_MSG serves as PEER_RESET if link is already down */
	1603	+ if (mtyp == RESET_MSG \|\| !link_is_up(l))
1601	1604	rc = tipc_link_fsm_evt(l, LINK_PEER_RESET_EVT);
1602	1605
1603	1606	/* ACTIVATE_MSG takes up link if it was already locally reset */
1604		− if ((mtyp == ACTIVATE_MSG) && (l->state == LINK_ESTABLISHING))
	1607	+ if (mtyp == ACTIVATE_MSG && l->state == LINK_ESTABLISHING)
1605	1608	rc = TIPC_LINK_UP_EVT;
1606	1609
1607	1610	l->peer_session = msg_session(hdr);