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

Merge branch 'cxgb4-next' 



Anish Bhatt says:

====================
All Chelsio drivers : Cleanup CPL messages macros

This patch series cleans up all register defines/MACROS defined in t4_msg.h and
affected files as part of the continuing cleanup effort

The patches series is created against 'net-next' tree and  includes patches
to the cxgb4, cxgb4vf, iw_cxgb4, cxgb4i and csiostor drivers.

We have included all the maintainers of respective drivers. Kindly review the
change and let us know in case of any review comments.
====================

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

drivers/infiniband/hw/cxgb4/cm.c

+49 −49
Original line number Diff line number Diff line
@@ -235,19 +235,19 @@ static void release_tid(struct c4iw_rdev *rdev, u32 hwtid, struct sk_buff *skb) 


static void set_emss(struct c4iw_ep *ep, u16 opt)

{

	ep->emss = ep->com.dev->rdev.lldi.mtus[GET_TCPOPT_MSS(opt)] -

	ep->emss = ep->com.dev->rdev.lldi.mtus[TCPOPT_MSS_G(opt)] -

		   ((AF_INET == ep->com.remote_addr.ss_family) ?

		    sizeof(struct iphdr) : sizeof(struct ipv6hdr)) -

		   sizeof(struct tcphdr);

	ep->mss = ep->emss;

	if (GET_TCPOPT_TSTAMP(opt))

	if (TCPOPT_TSTAMP_G(opt))

		ep->emss -= round_up(TCPOLEN_TIMESTAMP, 4);

	if (ep->emss < 128)

		ep->emss = 128;

	if (ep->emss & 7)

		PDBG("Warning: misaligned mtu idx %u mss %u emss=%u\n",

		     GET_TCPOPT_MSS(opt), ep->mss, ep->emss);

	PDBG("%s mss_idx %u mss %u emss=%u\n", __func__, GET_TCPOPT_MSS(opt),

		     TCPOPT_MSS_G(opt), ep->mss, ep->emss);

	PDBG("%s mss_idx %u mss %u emss=%u\n", __func__, TCPOPT_MSS_G(opt),

	     ep->mss, ep->emss);

}
@@ -652,24 +652,24 @@ static int send_connect(struct c4iw_ep *ep) 
	if (win > RCV_BUFSIZ_M)

		win = RCV_BUFSIZ_M;



	opt0 = (nocong ? NO_CONG(1) : 0) |

	opt0 = (nocong ? NO_CONG_F : 0) |

	       KEEP_ALIVE_F |

	       DELACK(1) |

	       DELACK_F |

	       WND_SCALE_V(wscale) |

	       MSS_IDX_V(mtu_idx) |

	       L2T_IDX_V(ep->l2t->idx) |

	       TX_CHAN_V(ep->tx_chan) |

	       SMAC_SEL_V(ep->smac_idx) |

	       DSCP(ep->tos) |

	       DSCP_V(ep->tos) |

	       ULP_MODE_V(ULP_MODE_TCPDDP) |

	       RCV_BUFSIZ_V(win);

	opt2 = RX_CHANNEL_V(0) |

	       CCTRL_ECN(enable_ecn) |

	       CCTRL_ECN_V(enable_ecn) |

	       RSS_QUEUE_VALID_F | RSS_QUEUE_V(ep->rss_qid);

	if (enable_tcp_timestamps)

		opt2 |= TSTAMPS_EN(1);

		opt2 |= TSTAMPS_EN_F;

	if (enable_tcp_sack)

		opt2 |= SACK_EN(1);

		opt2 |= SACK_EN_F;

	if (wscale && enable_tcp_window_scaling)

		opt2 |= WND_SCALE_EN_F;

	if (is_t5(ep->com.dev->rdev.lldi.adapter_type)) {
@@ -1042,7 +1042,7 @@ static int act_establish(struct c4iw_dev *dev, struct sk_buff *skb) 
	struct c4iw_ep *ep;

	struct cpl_act_establish *req = cplhdr(skb);

	unsigned int tid = GET_TID(req);

	unsigned int atid = GET_TID_TID(ntohl(req->tos_atid));

	unsigned int atid = TID_TID_G(ntohl(req->tos_atid));

	struct tid_info *t = dev->rdev.lldi.tids;



	ep = lookup_atid(t, atid);
@@ -1751,7 +1751,7 @@ static void send_fw_act_open_req(struct c4iw_ep *ep, unsigned int atid) 
	skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);

	req = (struct fw_ofld_connection_wr *)__skb_put(skb, sizeof(*req));

	memset(req, 0, sizeof(*req));

	req->op_compl = htonl(V_WR_OP(FW_OFLD_CONNECTION_WR));

	req->op_compl = htonl(WR_OP_V(FW_OFLD_CONNECTION_WR));

	req->len16_pkd = htonl(FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*req), 16)));

	req->le.filter = cpu_to_be32(cxgb4_select_ntuple(

				     ep->com.dev->rdev.lldi.ports[0],
@@ -1782,27 +1782,27 @@ static void send_fw_act_open_req(struct c4iw_ep *ep, unsigned int atid) 
	if (win > RCV_BUFSIZ_M)

		win = RCV_BUFSIZ_M;



	req->tcb.opt0 = (__force __be64) (TCAM_BYPASS(1) |

		(nocong ? NO_CONG(1) : 0) |

	req->tcb.opt0 = (__force __be64) (TCAM_BYPASS_F |

		(nocong ? NO_CONG_F : 0) |

		KEEP_ALIVE_F |

		DELACK(1) |

		DELACK_F |

		WND_SCALE_V(wscale) |

		MSS_IDX_V(mtu_idx) |

		L2T_IDX_V(ep->l2t->idx) |

		TX_CHAN_V(ep->tx_chan) |

		SMAC_SEL_V(ep->smac_idx) |

		DSCP(ep->tos) |

		DSCP_V(ep->tos) |

		ULP_MODE_V(ULP_MODE_TCPDDP) |

		RCV_BUFSIZ_V(win));

	req->tcb.opt2 = (__force __be32) (PACE(1) |

		TX_QUEUE(ep->com.dev->rdev.lldi.tx_modq[ep->tx_chan]) |

	req->tcb.opt2 = (__force __be32) (PACE_V(1) |

		TX_QUEUE_V(ep->com.dev->rdev.lldi.tx_modq[ep->tx_chan]) |

		RX_CHANNEL_V(0) |

		CCTRL_ECN(enable_ecn) |

		CCTRL_ECN_V(enable_ecn) |

		RSS_QUEUE_VALID_F | RSS_QUEUE_V(ep->rss_qid));

	if (enable_tcp_timestamps)

		req->tcb.opt2 |= (__force __be32)TSTAMPS_EN(1);

		req->tcb.opt2 |= (__force __be32)TSTAMPS_EN_F;

	if (enable_tcp_sack)

		req->tcb.opt2 |= (__force __be32)SACK_EN(1);

		req->tcb.opt2 |= (__force __be32)SACK_EN_F;

	if (wscale && enable_tcp_window_scaling)

		req->tcb.opt2 |= (__force __be32)WND_SCALE_EN_F;

	req->tcb.opt0 = cpu_to_be64((__force u64)req->tcb.opt0);
@@ -2023,10 +2023,10 @@ static int act_open_rpl(struct c4iw_dev *dev, struct sk_buff *skb) 
{

	struct c4iw_ep *ep;

	struct cpl_act_open_rpl *rpl = cplhdr(skb);

	unsigned int atid = GET_TID_TID(GET_AOPEN_ATID(

	unsigned int atid = TID_TID_G(AOPEN_ATID_G(

				      ntohl(rpl->atid_status)));

	struct tid_info *t = dev->rdev.lldi.tids;

	int status = GET_AOPEN_STATUS(ntohl(rpl->atid_status));

	int status = AOPEN_STATUS_G(ntohl(rpl->atid_status));

	struct sockaddr_in *la;

	struct sockaddr_in *ra;

	struct sockaddr_in6 *la6;
@@ -2064,7 +2064,7 @@ static int act_open_rpl(struct c4iw_dev *dev, struct sk_buff *skb) 
		if (ep->com.local_addr.ss_family == AF_INET &&

		    dev->rdev.lldi.enable_fw_ofld_conn) {

			send_fw_act_open_req(ep,

					     GET_TID_TID(GET_AOPEN_ATID(

					     TID_TID_G(AOPEN_ATID_G(

					     ntohl(rpl->atid_status))));

			return 0;

		}
@@ -2181,24 +2181,24 @@ static void accept_cr(struct c4iw_ep *ep, struct sk_buff *skb, 
	win = ep->rcv_win >> 10;

	if (win > RCV_BUFSIZ_M)

		win = RCV_BUFSIZ_M;

	opt0 = (nocong ? NO_CONG(1) : 0) |

	opt0 = (nocong ? NO_CONG_F : 0) |

	       KEEP_ALIVE_F |

	       DELACK(1) |

	       DELACK_F |

	       WND_SCALE_V(wscale) |

	       MSS_IDX_V(mtu_idx) |

	       L2T_IDX_V(ep->l2t->idx) |

	       TX_CHAN_V(ep->tx_chan) |

	       SMAC_SEL_V(ep->smac_idx) |

	       DSCP(ep->tos >> 2) |

	       DSCP_V(ep->tos >> 2) |

	       ULP_MODE_V(ULP_MODE_TCPDDP) |

	       RCV_BUFSIZ_V(win);

	opt2 = RX_CHANNEL_V(0) |

	       RSS_QUEUE_VALID_F | RSS_QUEUE_V(ep->rss_qid);



	if (enable_tcp_timestamps && req->tcpopt.tstamp)

		opt2 |= TSTAMPS_EN(1);

		opt2 |= TSTAMPS_EN_F;

	if (enable_tcp_sack && req->tcpopt.sack)

		opt2 |= SACK_EN(1);

		opt2 |= SACK_EN_F;

	if (wscale && enable_tcp_window_scaling)

		opt2 |= WND_SCALE_EN_F;

	if (enable_ecn) {
@@ -2208,7 +2208,7 @@ static void accept_cr(struct c4iw_ep *ep, struct sk_buff *skb, 
		tcph = (const void *)(req + 1) + G_ETH_HDR_LEN(hlen) +

			G_IP_HDR_LEN(hlen);

		if (tcph->ece && tcph->cwr)

			opt2 |= CCTRL_ECN(1);

			opt2 |= CCTRL_ECN_V(1);

	}

	if (is_t5(ep->com.dev->rdev.lldi.adapter_type)) {

		u32 isn = (prandom_u32() & ~7UL) - 1;
@@ -2277,7 +2277,7 @@ static int pass_accept_req(struct c4iw_dev *dev, struct sk_buff *skb) 
{

	struct c4iw_ep *child_ep = NULL, *parent_ep;

	struct cpl_pass_accept_req *req = cplhdr(skb);

	unsigned int stid = GET_POPEN_TID(ntohl(req->tos_stid));

	unsigned int stid = PASS_OPEN_TID_G(ntohl(req->tos_stid));

	struct tid_info *t = dev->rdev.lldi.tids;

	unsigned int hwtid = GET_TID(req);

	struct dst_entry *dst;
@@ -2310,14 +2310,14 @@ static int pass_accept_req(struct c4iw_dev *dev, struct sk_buff *skb) 
		     ntohs(peer_port), peer_mss);

		dst = find_route(dev, *(__be32 *)local_ip, *(__be32 *)peer_ip,

				 local_port, peer_port,

				 GET_POPEN_TOS(ntohl(req->tos_stid)));

				 PASS_OPEN_TOS_G(ntohl(req->tos_stid)));

	} else {

		PDBG("%s parent ep %p hwtid %u laddr %pI6 raddr %pI6 lport %d rport %d peer_mss %d\n"

		     , __func__, parent_ep, hwtid,

		     local_ip, peer_ip, ntohs(local_port),

		     ntohs(peer_port), peer_mss);

		dst = find_route6(dev, local_ip, peer_ip, local_port, peer_port,

				  PASS_OPEN_TOS(ntohl(req->tos_stid)),

				  PASS_OPEN_TOS_G(ntohl(req->tos_stid)),

				  ((struct sockaddr_in6 *)

				  &parent_ep->com.local_addr)->sin6_scope_id);

	}
@@ -2375,7 +2375,7 @@ static int pass_accept_req(struct c4iw_dev *dev, struct sk_buff *skb) 
	}

	c4iw_get_ep(&parent_ep->com);

	child_ep->parent_ep = parent_ep;

	child_ep->tos = GET_POPEN_TOS(ntohl(req->tos_stid));

	child_ep->tos = PASS_OPEN_TOS_G(ntohl(req->tos_stid));

	child_ep->dst = dst;

	child_ep->hwtid = hwtid;
@@ -3501,23 +3501,23 @@ static void build_cpl_pass_accept_req(struct sk_buff *skb, int stid , u8 tos) 
	req = (struct cpl_pass_accept_req *)__skb_push(skb, sizeof(*req));

	memset(req, 0, sizeof(*req));

	req->l2info = cpu_to_be16(V_SYN_INTF(intf) |

			 V_SYN_MAC_IDX(G_RX_MACIDX(

			 V_SYN_MAC_IDX(RX_MACIDX_G(

			 (__force int) htonl(l2info))) |

			 F_SYN_XACT_MATCH);

	eth_hdr_len = is_t4(dev->rdev.lldi.adapter_type) ?

			    G_RX_ETHHDR_LEN((__force int) htonl(l2info)) :

			    G_RX_T5_ETHHDR_LEN((__force int) htonl(l2info));

	req->hdr_len = cpu_to_be32(V_SYN_RX_CHAN(G_RX_CHAN(

			    RX_ETHHDR_LEN_G((__force int)htonl(l2info)) :

			    RX_T5_ETHHDR_LEN_G((__force int)htonl(l2info));

	req->hdr_len = cpu_to_be32(V_SYN_RX_CHAN(RX_CHAN_G(

					(__force int) htonl(l2info))) |

				   V_TCP_HDR_LEN(G_RX_TCPHDR_LEN(

				   V_TCP_HDR_LEN(RX_TCPHDR_LEN_G(

					(__force int) htons(hdr_len))) |

				   V_IP_HDR_LEN(G_RX_IPHDR_LEN(

				   V_IP_HDR_LEN(RX_IPHDR_LEN_G(

					(__force int) htons(hdr_len))) |

				   V_ETH_HDR_LEN(G_RX_ETHHDR_LEN(eth_hdr_len)));

				   V_ETH_HDR_LEN(RX_ETHHDR_LEN_G(eth_hdr_len)));

	req->vlan = (__force __be16) vlantag;

	req->len = (__force __be16) len;

	req->tos_stid = cpu_to_be32(PASS_OPEN_TID(stid) |

				    PASS_OPEN_TOS(tos));

	req->tos_stid = cpu_to_be32(PASS_OPEN_TID_V(stid) |

				    PASS_OPEN_TOS_V(tos));

	req->tcpopt.mss = htons(tmp_opt.mss_clamp);

	if (tmp_opt.wscale_ok)

		req->tcpopt.wsf = tmp_opt.snd_wscale;
@@ -3542,7 +3542,7 @@ static void send_fw_pass_open_req(struct c4iw_dev *dev, struct sk_buff *skb, 
	req_skb = alloc_skb(sizeof(struct fw_ofld_connection_wr), GFP_KERNEL);

	req = (struct fw_ofld_connection_wr *)__skb_put(req_skb, sizeof(*req));

	memset(req, 0, sizeof(*req));

	req->op_compl = htonl(V_WR_OP(FW_OFLD_CONNECTION_WR) | FW_WR_COMPL_F);

	req->op_compl = htonl(WR_OP_V(FW_OFLD_CONNECTION_WR) | FW_WR_COMPL_F);

	req->len16_pkd = htonl(FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*req), 16)));

	req->le.version_cpl = htonl(FW_OFLD_CONNECTION_WR_CPL_F);

	req->le.filter = (__force __be32) filter;
@@ -3556,7 +3556,7 @@ static void send_fw_pass_open_req(struct c4iw_dev *dev, struct sk_buff *skb, 
		 htonl(FW_OFLD_CONNECTION_WR_T_STATE_V(TCP_SYN_RECV) |

			FW_OFLD_CONNECTION_WR_RCV_SCALE_V(cpl->tcpopt.wsf) |

			FW_OFLD_CONNECTION_WR_ASTID_V(

			GET_PASS_OPEN_TID(ntohl(cpl->tos_stid))));

			PASS_OPEN_TID_G(ntohl(cpl->tos_stid))));



	/*

	 * We store the qid in opt2 which will be used by the firmware
@@ -3613,7 +3613,7 @@ static int rx_pkt(struct c4iw_dev *dev, struct sk_buff *skb) 
	struct neighbour *neigh;



	/* Drop all non-SYN packets */

	if (!(cpl->l2info & cpu_to_be32(F_RXF_SYN)))

	if (!(cpl->l2info & cpu_to_be32(RXF_SYN_F)))

		goto reject;



	/*
@@ -3635,8 +3635,8 @@ static int rx_pkt(struct c4iw_dev *dev, struct sk_buff *skb) 
	}



	eth_hdr_len = is_t4(dev->rdev.lldi.adapter_type) ?

			    G_RX_ETHHDR_LEN(htonl(cpl->l2info)) :

			    G_RX_T5_ETHHDR_LEN(htonl(cpl->l2info));

			    RX_ETHHDR_LEN_G(htonl(cpl->l2info)) :

			    RX_T5_ETHHDR_LEN_G(htonl(cpl->l2info));

	if (eth_hdr_len == ETH_HLEN) {

		eh = (struct ethhdr *)(req + 1);

		iph = (struct iphdr *)(eh + 1);

drivers/infiniband/hw/cxgb4/mem.c

+2 −2
Original line number Diff line number Diff line
@@ -86,14 +86,14 @@ static int _c4iw_write_mem_dma_aligned(struct c4iw_rdev *rdev, u32 addr, 
	req->wr.wr_lo = wait ? (__force __be64)(unsigned long) &wr_wait : 0L;

	req->wr.wr_mid = cpu_to_be32(FW_WR_LEN16_V(DIV_ROUND_UP(wr_len, 16)));

	req->cmd = cpu_to_be32(ULPTX_CMD_V(ULP_TX_MEM_WRITE));

	req->cmd |= cpu_to_be32(V_T5_ULP_MEMIO_ORDER(1));

	req->cmd |= cpu_to_be32(T5_ULP_MEMIO_ORDER_V(1));

	req->dlen = cpu_to_be32(ULP_MEMIO_DATA_LEN_V(len>>5));

	req->len16 = cpu_to_be32(DIV_ROUND_UP(wr_len-sizeof(req->wr), 16));

	req->lock_addr = cpu_to_be32(ULP_MEMIO_ADDR_V(addr));



	sgl = (struct ulptx_sgl *)(req + 1);

	sgl->cmd_nsge = cpu_to_be32(ULPTX_CMD_V(ULP_TX_SC_DSGL) |

				    ULPTX_NSGE(1));

				    ULPTX_NSGE_V(1));

	sgl->len0 = cpu_to_be32(len);

	sgl->addr0 = cpu_to_be64(data);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

+8 −8
Original line number Diff line number Diff line
@@ -672,7 +672,7 @@ static void filter_rpl(struct adapter *adap, const struct cpl_set_tcb_rpl *rpl) 
	if (idx >= adap->tids.ftid_base && nidx <

	   (adap->tids.nftids + adap->tids.nsftids)) {

		idx = nidx;

		ret = GET_TCB_COOKIE(rpl->cookie);

		ret = TCB_COOKIE_G(rpl->cookie);

		f = &adap->tids.ftid_tab[idx];



		if (ret == FW_FILTER_WR_FLT_DELETED) {
@@ -724,7 +724,7 @@ static int fwevtq_handler(struct sge_rspq *q, const __be64 *rsp, 


	if (likely(opcode == CPL_SGE_EGR_UPDATE)) {

		const struct cpl_sge_egr_update *p = (void *)rsp;

		unsigned int qid = EGR_QID(ntohl(p->opcode_qid));

		unsigned int qid = EGR_QID_G(ntohl(p->opcode_qid));

		struct sge_txq *txq;



		txq = q->adap->sge.egr_map[qid - q->adap->sge.egr_start];
@@ -3416,8 +3416,8 @@ int cxgb4_create_server(const struct net_device *dev, unsigned int stid, 
	req->peer_ip = htonl(0);

	chan = rxq_to_chan(&adap->sge, queue);

	req->opt0 = cpu_to_be64(TX_CHAN_V(chan));

	req->opt1 = cpu_to_be64(CONN_POLICY_ASK |

				SYN_RSS_ENABLE | SYN_RSS_QUEUE(queue));

	req->opt1 = cpu_to_be64(CONN_POLICY_V(CPL_CONN_POLICY_ASK) |

				SYN_RSS_ENABLE_F | SYN_RSS_QUEUE_V(queue));

	ret = t4_mgmt_tx(adap, skb);

	return net_xmit_eval(ret);

}
@@ -3459,8 +3459,8 @@ int cxgb4_create_server6(const struct net_device *dev, unsigned int stid, 
	req->peer_ip_lo = cpu_to_be64(0);

	chan = rxq_to_chan(&adap->sge, queue);

	req->opt0 = cpu_to_be64(TX_CHAN_V(chan));

	req->opt1 = cpu_to_be64(CONN_POLICY_ASK |

				SYN_RSS_ENABLE | SYN_RSS_QUEUE(queue));

	req->opt1 = cpu_to_be64(CONN_POLICY_V(CPL_CONN_POLICY_ASK) |

				SYN_RSS_ENABLE_F | SYN_RSS_QUEUE_V(queue));

	ret = t4_mgmt_tx(adap, skb);

	return net_xmit_eval(ret);

}
@@ -3483,8 +3483,8 @@ int cxgb4_remove_server(const struct net_device *dev, unsigned int stid, 
	req = (struct cpl_close_listsvr_req *)__skb_put(skb, sizeof(*req));

	INIT_TP_WR(req, 0);

	OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_CLOSE_LISTSRV_REQ, stid));

	req->reply_ctrl = htons(NO_REPLY(0) | (ipv6 ? LISTSVR_IPV6(1) :

				LISTSVR_IPV6(0)) | QUEUENO(queue));

	req->reply_ctrl = htons(NO_REPLY_V(0) | (ipv6 ? LISTSVR_IPV6_V(1) :

				LISTSVR_IPV6_V(0)) | QUEUENO_V(queue));

	ret = t4_mgmt_tx(adap, skb);

	return net_xmit_eval(ret);

}

drivers/net/ethernet/chelsio/cxgb4/l2t.c

+2 −2
Original line number Diff line number Diff line
@@ -151,8 +151,8 @@ static int write_l2e(struct adapter *adap, struct l2t_entry *e, int sync) 


	OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_L2T_WRITE_REQ,

					e->idx | (sync ? F_SYNC_WR : 0) |

					TID_QID(adap->sge.fw_evtq.abs_id)));

	req->params = htons(L2T_W_PORT(e->lport) | L2T_W_NOREPLY(!sync));

					TID_QID_V(adap->sge.fw_evtq.abs_id)));

	req->params = htons(L2T_W_PORT_V(e->lport) | L2T_W_NOREPLY_V(!sync));

	req->l2t_idx = htons(e->idx);

	req->vlan = htons(e->vlan);

	if (e->neigh && !(e->neigh->dev->flags & IFF_LOOPBACK))

drivers/net/ethernet/chelsio/cxgb4/sge.c

+5 −4
Original line number Diff line number Diff line
@@ -821,7 +821,8 @@ static void write_sgl(const struct sk_buff *skb, struct sge_txq *q, 
		sgl->addr0 = cpu_to_be64(addr[1]);

	}



	sgl->cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) | ULPTX_NSGE(nfrags));

	sgl->cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) |

			      ULPTX_NSGE_V(nfrags));

	if (likely(--nfrags == 0))

		return;

	/*
@@ -1761,7 +1762,7 @@ int t4_ethrx_handler(struct sge_rspq *q, const __be64 *rsp, 
	pkt = (const struct cpl_rx_pkt *)rsp;

	csum_ok = pkt->csum_calc && !pkt->err_vec &&

		  (q->netdev->features & NETIF_F_RXCSUM);

	if ((pkt->l2info & htonl(RXF_TCP)) &&

	if ((pkt->l2info & htonl(RXF_TCP_F)) &&

	    (q->netdev->features & NETIF_F_GRO) && csum_ok && !pkt->ip_frag) {

		do_gro(rxq, si, pkt);

		return 0;
@@ -1783,11 +1784,11 @@ int t4_ethrx_handler(struct sge_rspq *q, const __be64 *rsp, 


	rxq->stats.pkts++;



	if (csum_ok && (pkt->l2info & htonl(RXF_UDP | RXF_TCP))) {

	if (csum_ok && (pkt->l2info & htonl(RXF_UDP_F | RXF_TCP_F))) {

		if (!pkt->ip_frag) {

			skb->ip_summed = CHECKSUM_UNNECESSARY;

			rxq->stats.rx_cso++;

		} else if (pkt->l2info & htonl(RXF_IP)) {

		} else if (pkt->l2info & htonl(RXF_IP_F)) {

			__sum16 c = (__force __sum16)pkt->csum;

			skb->csum = csum_unfold(c);

			skb->ip_summed = CHECKSUM_COMPLETE;

CRA Git | Maintained and supported by SUSTech CRA and CCSE