RDMA/cxgb4: Fix LE hash collision bug for active open connection (5be78ee9) · Commits · 戴 / test

drivers/infiniband/hw/cxgb4/cm.c

+152 −6

Original line number	Diff line number	Diff line
		@@ -61,6 +61,14 @@ static char *states[] = {
		NULL,
		};

		static int nocong;
		module_param(nocong, int, 0644);
		MODULE_PARM_DESC(nocong, "Turn of congestion control (default=0)");

		static int enable_ecn;
		module_param(enable_ecn, int, 0644);
		MODULE_PARM_DESC(enable_ecn, "Enable ECN (default=0/disabled)");

		static int dack_mode = 1;
		module_param(dack_mode, int, 0644);
		MODULE_PARM_DESC(dack_mode, "Delayed ack mode (default=1)");
		@@ -441,6 +449,50 @@ static int send_abort(struct c4iw_ep ep, struct sk_buff skb, gfp_t gfp)
		return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
		}

		#define VLAN_NONE 0xfff
		#define FILTER_SEL_VLAN_NONE 0xffff
		#define FILTER_SEL_WIDTH_P_FC (3+1) /* port uses 3 bits, FCoE one bit */
		#define FILTER_SEL_WIDTH_VIN_P_FC \
		(6 + 7 + FILTER_SEL_WIDTH_P_FC) /* 6 bits are unused, VF uses 7 bits*/
		#define FILTER_SEL_WIDTH_TAG_P_FC \
		(3 + FILTER_SEL_WIDTH_VIN_P_FC) /* PF uses 3 bits */
		#define FILTER_SEL_WIDTH_VLD_TAG_P_FC (1 + FILTER_SEL_WIDTH_TAG_P_FC)

		static unsigned int select_ntuple(struct c4iw_dev dev, struct dst_entry dst,
		struct l2t_entry *l2t)
		{
		unsigned int ntuple = 0;
		u32 viid;

		switch (dev->rdev.lldi.filt_mode) {

		/* default filter mode */
		case HW_TPL_FR_MT_PR_IV_P_FC:
		if (l2t->vlan == VLAN_NONE)
		ntuple \|= FILTER_SEL_VLAN_NONE << FILTER_SEL_WIDTH_P_FC;
		else {
		ntuple \|= l2t->vlan << FILTER_SEL_WIDTH_P_FC;
		ntuple \|= 1 << FILTER_SEL_WIDTH_VLD_TAG_P_FC;
		}
		ntuple \|= l2t->lport << S_PORT \| IPPROTO_TCP <<
		FILTER_SEL_WIDTH_VLD_TAG_P_FC;
		break;
		case HW_TPL_FR_MT_PR_OV_P_FC: {
		viid = cxgb4_port_viid(l2t->neigh->dev);

		ntuple \|= FW_VIID_VIN_GET(viid) << FILTER_SEL_WIDTH_P_FC;
		ntuple \|= FW_VIID_PFN_GET(viid) << FILTER_SEL_WIDTH_VIN_P_FC;
		ntuple \|= FW_VIID_VIVLD_GET(viid) << FILTER_SEL_WIDTH_TAG_P_FC;
		ntuple \|= l2t->lport << S_PORT \| IPPROTO_TCP <<
		FILTER_SEL_WIDTH_VLD_TAG_P_FC;
		break;
		}
		default:
		break;
		}
		return ntuple;
		}

		static int send_connect(struct c4iw_ep *ep)
		{
		struct cpl_act_open_req *req;
		@@ -463,7 +515,8 @@ static int send_connect(struct c4iw_ep *ep)

		cxgb4_best_mtu(ep->com.dev->rdev.lldi.mtus, ep->mtu, &mtu_idx);
		wscale = compute_wscale(rcv_win);
		opt0 = KEEP_ALIVE(1) \|
		opt0 = (nocong ? NO_CONG(1) : 0) \|
		KEEP_ALIVE(1) \|
		DELACK(1) \|
		WND_SCALE(wscale) \|
		MSS_IDX(mtu_idx) \|
		@@ -474,6 +527,7 @@ static int send_connect(struct c4iw_ep *ep)
		ULP_MODE(ULP_MODE_TCPDDP) \|
		RCV_BUFSIZ(rcv_win>>10);
		opt2 = RX_CHANNEL(0) \|
		CCTRL_ECN(enable_ecn) \|
		RSS_QUEUE_VALID \| RSS_QUEUE(ep->rss_qid);
		if (enable_tcp_timestamps)
		opt2 \|= TSTAMPS_EN(1);
		@@ -492,7 +546,7 @@ static int send_connect(struct c4iw_ep *ep)
		req->local_ip = ep->com.local_addr.sin_addr.s_addr;
		req->peer_ip = ep->com.remote_addr.sin_addr.s_addr;
		req->opt0 = cpu_to_be64(opt0);
		req->params = 0;
		req->params = cpu_to_be32(select_ntuple(ep->com.dev, ep->dst, ep->l2t));
		req->opt2 = cpu_to_be32(opt2);
		return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
		}
		@@ -1383,6 +1437,61 @@ static int abort_rpl(struct c4iw_dev dev, struct sk_buff skb)
		return 0;
		}

		static void send_fw_act_open_req(struct c4iw_ep *ep, unsigned int atid)
		{
		struct sk_buff *skb;
		struct fw_ofld_connection_wr *req;
		unsigned int mtu_idx;
		int wscale;

		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->len16_pkd = htonl(FW_WR_LEN16(DIV_ROUND_UP(sizeof(*req), 16)));
		req->le.filter = cpu_to_be32(select_ntuple(ep->com.dev, ep->dst,
		ep->l2t));
		req->le.lport = ep->com.local_addr.sin_port;
		req->le.pport = ep->com.remote_addr.sin_port;
		req->le.u.ipv4.lip = ep->com.local_addr.sin_addr.s_addr;
		req->le.u.ipv4.pip = ep->com.remote_addr.sin_addr.s_addr;
		req->tcb.t_state_to_astid =
		htonl(V_FW_OFLD_CONNECTION_WR_T_STATE(TCP_SYN_SENT) \|
		V_FW_OFLD_CONNECTION_WR_ASTID(atid));
		req->tcb.cplrxdataack_cplpassacceptrpl =
		htons(F_FW_OFLD_CONNECTION_WR_CPLRXDATAACK);
		req->tcb.tx_max = jiffies;
		cxgb4_best_mtu(ep->com.dev->rdev.lldi.mtus, ep->mtu, &mtu_idx);
		wscale = compute_wscale(rcv_win);
		req->tcb.opt0 = TCAM_BYPASS(1) \|
		(nocong ? NO_CONG(1) : 0) \|
		KEEP_ALIVE(1) \|
		DELACK(1) \|
		WND_SCALE(wscale) \|
		MSS_IDX(mtu_idx) \|
		L2T_IDX(ep->l2t->idx) \|
		TX_CHAN(ep->tx_chan) \|
		SMAC_SEL(ep->smac_idx) \|
		DSCP(ep->tos) \|
		ULP_MODE(ULP_MODE_TCPDDP) \|
		RCV_BUFSIZ(rcv_win >> 10);
		req->tcb.opt2 = PACE(1) \|
		TX_QUEUE(ep->com.dev->rdev.lldi.tx_modq[ep->tx_chan]) \|
		RX_CHANNEL(0) \|
		CCTRL_ECN(enable_ecn) \|
		RSS_QUEUE_VALID \| RSS_QUEUE(ep->rss_qid);
		if (enable_tcp_timestamps)
		req->tcb.opt2 \|= TSTAMPS_EN(1);
		if (enable_tcp_sack)
		req->tcb.opt2 \|= SACK_EN(1);
		if (wscale && enable_tcp_window_scaling)
		req->tcb.opt2 \|= WND_SCALE_EN(1);
		req->tcb.opt0 = cpu_to_be64(req->tcb.opt0);
		req->tcb.opt2 = cpu_to_be32(req->tcb.opt2);
		set_wr_txq(skb, CPL_PRIORITY_CONTROL, 0);
		c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
		}

		/*
		* Return whether a failed active open has allocated a TID
		*/
		@@ -1419,6 +1528,14 @@ static int act_open_rpl(struct c4iw_dev dev, struct sk_buff skb)
		case CPL_ERR_CONN_RESET:
		case CPL_ERR_CONN_TIMEDOUT:
		break;
		case CPL_ERR_TCAM_FULL:
		mutex_lock(&dev->rdev.stats.lock);
		dev->rdev.stats.tcam_full++;
		mutex_unlock(&dev->rdev.stats.lock);
		send_fw_act_open_req(ep,
		GET_TID_TID(GET_AOPEN_ATID(ntohl(rpl->atid_status))));
		return 0;
		break;
		default:
		printk(KERN_INFO MOD "Active open failure - "
		"atid %u status %u errno %d %pI4:%u->%pI4:%u\n",
		@@ -1510,14 +1627,15 @@ static void accept_cr(struct c4iw_ep ep, __be32 peer_ip, struct sk_buff skb,
		skb_get(skb);
		cxgb4_best_mtu(ep->com.dev->rdev.lldi.mtus, ep->mtu, &mtu_idx);
		wscale = compute_wscale(rcv_win);
		opt0 = KEEP_ALIVE(1) \|
		opt0 = (nocong ? NO_CONG(1) : 0) \|
		KEEP_ALIVE(1) \|
		DELACK(1) \|
		WND_SCALE(wscale) \|
		MSS_IDX(mtu_idx) \|
		L2T_IDX(ep->l2t->idx) \|
		TX_CHAN(ep->tx_chan) \|
		SMAC_SEL(ep->smac_idx) \|
		DSCP(ep->tos) \|
		DSCP(ep->tos >> 2) \|
		ULP_MODE(ULP_MODE_TCPDDP) \|
		RCV_BUFSIZ(rcv_win>>10);
		opt2 = RX_CHANNEL(0) \|
		@@ -1529,6 +1647,15 @@ static void accept_cr(struct c4iw_ep ep, __be32 peer_ip, struct sk_buff skb,
		opt2 \|= SACK_EN(1);
		if (wscale && enable_tcp_window_scaling)
		opt2 \|= WND_SCALE_EN(1);
		if (enable_ecn) {
		const struct tcphdr *tcph;
		u32 hlen = ntohl(req->hdr_len);

		tcph = (const void *)(req + 1) + G_ETH_HDR_LEN(hlen) +
		G_IP_HDR_LEN(hlen);
		if (tcph->ece && tcph->cwr)
		opt2 \|= CCTRL_ECN(1);
		}

		rpl = cplhdr(skb);
		INIT_TP_WR(rpl, ep->hwtid);
		@@ -2647,11 +2774,14 @@ static int fw6_msg(struct c4iw_dev dev, struct sk_buff skb)
		struct cpl_fw6_msg *rpl = cplhdr(skb);
		struct c4iw_wr_wait *wr_waitp;
		int ret;
		u8 opcode;
		struct cpl_fw6_msg_ofld_connection_wr_rpl *req;
		struct c4iw_ep *ep;

		PDBG("%s type %u\n", __func__, rpl->type);

		switch (rpl->type) {
		case 1:
		case FW6_TYPE_WR_RPL:
		ret = (int)((be64_to_cpu(rpl->data[0]) >> 8) & 0xff);
		wr_waitp = (struct c4iw_wr_wait *)(__force unsigned long) rpl->data[1];
		PDBG("%s wr_waitp %p ret %u\n", __func__, wr_waitp, ret);
		@@ -2659,9 +2789,25 @@ static int fw6_msg(struct c4iw_dev dev, struct sk_buff skb)
		c4iw_wake_up(wr_waitp, ret ? -ret : 0);
		kfree_skb(skb);
		break;
		case 2:
		case FW6_TYPE_CQE:
		sched(dev, skb);
		break;
		case FW6_TYPE_OFLD_CONNECTION_WR_RPL:
		opcode = (const u8 )rpl->data;
		if (opcode == FW_OFLD_CONNECTION_WR) {
		req =
		(struct cpl_fw6_msg_ofld_connection_wr_rpl *)rpl->data;
		if (req->t_state == TCP_SYN_SENT
		&& (req->retval == FW_ENOMEM
		\|\| req->retval == FW_EADDRINUSE)) {
		ep = (struct c4iw_ep *)
		lookup_atid(dev->rdev.lldi.tids,
		req->tid);
		c4iw_l2t_send(&dev->rdev, skb, ep->l2t);
		return 0;
		}
		}
		break;
		default:
		printk(KERN_ERR MOD "%s unexpected fw6 msg type %u\n", __func__,
		rpl->type);

drivers/infiniband/hw/cxgb4/iw_cxgb4.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -130,6 +130,7 @@ struct c4iw_stats {
		u64 db_empty;
		u64 db_drop;
		u64 db_state_transitions;
		u64 tcam_full;
		};

		struct c4iw_rdev {

drivers/net/ethernet/chelsio/cxgb4/t4_msg.h

+19 −0

Original line number	Diff line number	Diff line
		@@ -193,6 +193,10 @@ struct work_request_hdr {
		__be64 wr_lo;
		};

		/* wr_hi fields */
		#define S_WR_OP 24
		#define V_WR_OP(x) ((__u64)(x) << S_WR_OP)

		#define WR_HDR struct work_request_hdr wr

		struct cpl_pass_open_req {
		@@ -204,12 +208,14 @@ struct cpl_pass_open_req {
		__be32 peer_ip;
		__be64 opt0;
		#define TX_CHAN(x) ((x) << 2)
		#define NO_CONG(x) ((x) << 4)
		#define DELACK(x) ((x) << 5)
		#define ULP_MODE(x) ((x) << 8)
		#define RCV_BUFSIZ(x) ((x) << 12)
		#define DSCP(x) ((x) << 22)
		#define SMAC_SEL(x) ((u64)(x) << 28)
		#define L2T_IDX(x) ((u64)(x) << 36)
		#define TCAM_BYPASS(x) ((u64)(x) << 48)
		#define NAGLE(x) ((u64)(x) << 49)
		#define WND_SCALE(x) ((u64)(x) << 50)
		#define KEEP_ALIVE(x) ((u64)(x) << 54)
		@@ -247,8 +253,10 @@ struct cpl_pass_accept_rpl {
		#define RSS_QUEUE_VALID (1 << 10)
		#define RX_COALESCE_VALID(x) ((x) << 11)
		#define RX_COALESCE(x) ((x) << 12)
		#define PACE(x) ((x) << 16)
		#define TX_QUEUE(x) ((x) << 23)
		#define RX_CHANNEL(x) ((x) << 26)
		#define CCTRL_ECN(x) ((x) << 27)
		#define WND_SCALE_EN(x) ((x) << 28)
		#define TSTAMPS_EN(x) ((x) << 29)
		#define SACK_EN(x) ((x) << 30)
		@@ -635,6 +643,17 @@ struct cpl_fw6_msg {
		/* cpl_fw6_msg.type values */
		enum {
		FW6_TYPE_CMD_RPL = 0,
		FW6_TYPE_WR_RPL = 1,
		FW6_TYPE_CQE = 2,
		FW6_TYPE_OFLD_CONNECTION_WR_RPL = 3,
		};

		struct cpl_fw6_msg_ofld_connection_wr_rpl {
		__u64 cookie;
		__be32 tid; /* or atid in case of active failure */
		__u8 t_state;
		__u8 retval;
		__u8 rsvd[2];
		};

		enum {

drivers/net/ethernet/chelsio/cxgb4/t4_regs.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -1097,4 +1097,6 @@

		#define A_TP_TX_SCHED_PCMD 0x25

		#define S_PORT 1

		#endif /* __T4_REGS_H */

drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h

+141 −2

Original line number	Diff line number	Diff line
		@@ -35,8 +35,43 @@
		#ifndef _T4FW_INTERFACE_H_
		#define _T4FW_INTERFACE_H_

		enum fw_ret_val {
		FW_ENOEXEC = 8, /* Exec format error; inv microcode */
		enum fw_retval {
		FW_SUCCESS = 0, /* completed sucessfully */
		FW_EPERM = 1, /* operation not permitted */
		FW_ENOENT = 2, /* no such file or directory */
		FW_EIO = 5, /* input/output error; hw bad */
		FW_ENOEXEC = 8, /* exec format error; inv microcode */
		FW_EAGAIN = 11, /* try again */
		FW_ENOMEM = 12, /* out of memory */
		FW_EFAULT = 14, /* bad address; fw bad */
		FW_EBUSY = 16, /* resource busy */
		FW_EEXIST = 17, /* file exists */
		FW_EINVAL = 22, /* invalid argument */
		FW_ENOSPC = 28, /* no space left on device */
		FW_ENOSYS = 38, /* functionality not implemented */
		FW_EPROTO = 71, /* protocol error */
		FW_EADDRINUSE = 98, /* address already in use */
		FW_EADDRNOTAVAIL = 99, /* cannot assigned requested address */
		FW_ENETDOWN = 100, /* network is down */
		FW_ENETUNREACH = 101, /* network is unreachable */
		FW_ENOBUFS = 105, /* no buffer space available */
		FW_ETIMEDOUT = 110, /* timeout */
		FW_EINPROGRESS = 115, /* fw internal */
		FW_SCSI_ABORT_REQUESTED = 128, /* */
		FW_SCSI_ABORT_TIMEDOUT = 129, /* */
		FW_SCSI_ABORTED = 130, /* */
		FW_SCSI_CLOSE_REQUESTED = 131, /* */
		FW_ERR_LINK_DOWN = 132, /* */
		FW_RDEV_NOT_READY = 133, /* */
		FW_ERR_RDEV_LOST = 134, /* */
		FW_ERR_RDEV_LOGO = 135, /* */
		FW_FCOE_NO_XCHG = 136, /* */
		FW_SCSI_RSP_ERR = 137, /* */
		FW_ERR_RDEV_IMPL_LOGO = 138, /* */
		FW_SCSI_UNDER_FLOW_ERR = 139, /* */
		FW_SCSI_OVER_FLOW_ERR = 140, /* */
		FW_SCSI_DDP_ERR = 141, /* DDP error*/
		FW_SCSI_TASK_ERR = 142, /* No SCSI tasks available */
		};

		#define FW_T4VF_SGE_BASE_ADDR 0x0000
		@@ -50,6 +85,7 @@ enum fw_wr_opcodes {
		FW_ULPTX_WR = 0x04,
		FW_TP_WR = 0x05,
		FW_ETH_TX_PKT_WR = 0x08,
		FW_OFLD_CONNECTION_WR = 0x2f,
		FW_FLOWC_WR = 0x0a,
		FW_OFLD_TX_DATA_WR = 0x0b,
		FW_CMD_WR = 0x10,
		@@ -85,6 +121,7 @@ struct fw_wr_hdr {
		#define FW_WR_LEN16(x) ((x) << 0)

		#define HW_TPL_FR_MT_PR_IV_P_FC 0X32B
		#define HW_TPL_FR_MT_PR_OV_P_FC 0X327

		/* filter wr reply code in cookie in CPL_SET_TCB_RPL */
		enum fw_filter_wr_cookie {
		@@ -379,6 +416,108 @@ struct fw_eth_tx_pkt_wr {
		__be64 r3;
		};

		struct fw_ofld_connection_wr {
		__be32 op_compl;
		__be32 len16_pkd;
		__u64 cookie;
		__be64 r2;
		__be64 r3;
		struct fw_ofld_connection_le {
		__be32 version_cpl;
		__be32 filter;
		__be32 r1;
		__be16 lport;
		__be16 pport;
		union fw_ofld_connection_leip {
		struct fw_ofld_connection_le_ipv4 {
		__be32 pip;
		__be32 lip;
		__be64 r0;
		__be64 r1;
		__be64 r2;
		} ipv4;
		struct fw_ofld_connection_le_ipv6 {
		__be64 pip_hi;
		__be64 pip_lo;
		__be64 lip_hi;
		__be64 lip_lo;
		} ipv6;
		} u;
		} le;
		struct fw_ofld_connection_tcb {
		__be32 t_state_to_astid;
		__be16 cplrxdataack_cplpassacceptrpl;
		__be16 rcv_adv;
		__be32 rcv_nxt;
		__be32 tx_max;
		__be64 opt0;
		__be32 opt2;
		__be32 r1;
		__be64 r2;
		__be64 r3;
		} tcb;
		};

		#define S_FW_OFLD_CONNECTION_WR_VERSION 31
		#define M_FW_OFLD_CONNECTION_WR_VERSION 0x1
		#define V_FW_OFLD_CONNECTION_WR_VERSION(x) \
		((x) << S_FW_OFLD_CONNECTION_WR_VERSION)
		#define G_FW_OFLD_CONNECTION_WR_VERSION(x) \
		(((x) >> S_FW_OFLD_CONNECTION_WR_VERSION) & \
		M_FW_OFLD_CONNECTION_WR_VERSION)
		#define F_FW_OFLD_CONNECTION_WR_VERSION \
		V_FW_OFLD_CONNECTION_WR_VERSION(1U)

		#define S_FW_OFLD_CONNECTION_WR_CPL 30
		#define M_FW_OFLD_CONNECTION_WR_CPL 0x1
		#define V_FW_OFLD_CONNECTION_WR_CPL(x) ((x) << S_FW_OFLD_CONNECTION_WR_CPL)
		#define G_FW_OFLD_CONNECTION_WR_CPL(x) \
		(((x) >> S_FW_OFLD_CONNECTION_WR_CPL) & M_FW_OFLD_CONNECTION_WR_CPL)
		#define F_FW_OFLD_CONNECTION_WR_CPL V_FW_OFLD_CONNECTION_WR_CPL(1U)

		#define S_FW_OFLD_CONNECTION_WR_T_STATE 28
		#define M_FW_OFLD_CONNECTION_WR_T_STATE 0xf
		#define V_FW_OFLD_CONNECTION_WR_T_STATE(x) \
		((x) << S_FW_OFLD_CONNECTION_WR_T_STATE)
		#define G_FW_OFLD_CONNECTION_WR_T_STATE(x) \
		(((x) >> S_FW_OFLD_CONNECTION_WR_T_STATE) & \
		M_FW_OFLD_CONNECTION_WR_T_STATE)

		#define S_FW_OFLD_CONNECTION_WR_RCV_SCALE 24
		#define M_FW_OFLD_CONNECTION_WR_RCV_SCALE 0xf
		#define V_FW_OFLD_CONNECTION_WR_RCV_SCALE(x) \
		((x) << S_FW_OFLD_CONNECTION_WR_RCV_SCALE)
		#define G_FW_OFLD_CONNECTION_WR_RCV_SCALE(x) \
		(((x) >> S_FW_OFLD_CONNECTION_WR_RCV_SCALE) & \
		M_FW_OFLD_CONNECTION_WR_RCV_SCALE)

		#define S_FW_OFLD_CONNECTION_WR_ASTID 0
		#define M_FW_OFLD_CONNECTION_WR_ASTID 0xffffff
		#define V_FW_OFLD_CONNECTION_WR_ASTID(x) \
		((x) << S_FW_OFLD_CONNECTION_WR_ASTID)
		#define G_FW_OFLD_CONNECTION_WR_ASTID(x) \
		(((x) >> S_FW_OFLD_CONNECTION_WR_ASTID) & M_FW_OFLD_CONNECTION_WR_ASTID)

		#define S_FW_OFLD_CONNECTION_WR_CPLRXDATAACK 15
		#define M_FW_OFLD_CONNECTION_WR_CPLRXDATAACK 0x1
		#define V_FW_OFLD_CONNECTION_WR_CPLRXDATAACK(x) \
		((x) << S_FW_OFLD_CONNECTION_WR_CPLRXDATAACK)
		#define G_FW_OFLD_CONNECTION_WR_CPLRXDATAACK(x) \
		(((x) >> S_FW_OFLD_CONNECTION_WR_CPLRXDATAACK) & \
		M_FW_OFLD_CONNECTION_WR_CPLRXDATAACK)
		#define F_FW_OFLD_CONNECTION_WR_CPLRXDATAACK \
		V_FW_OFLD_CONNECTION_WR_CPLRXDATAACK(1U)

		#define S_FW_OFLD_CONNECTION_WR_CPLPASSACCEPTRPL 14
		#define M_FW_OFLD_CONNECTION_WR_CPLPASSACCEPTRPL 0x1
		#define V_FW_OFLD_CONNECTION_WR_CPLPASSACCEPTRPL(x) \
		((x) << S_FW_OFLD_CONNECTION_WR_CPLPASSACCEPTRPL)
		#define G_FW_OFLD_CONNECTION_WR_CPLPASSACCEPTRPL(x) \
		(((x) >> S_FW_OFLD_CONNECTION_WR_CPLPASSACCEPTRPL) & \
		M_FW_OFLD_CONNECTION_WR_CPLPASSACCEPTRPL)
		#define F_FW_OFLD_CONNECTION_WR_CPLPASSACCEPTRPL \
		V_FW_OFLD_CONNECTION_WR_CPLPASSACCEPTRPL(1U)

		enum fw_flowc_mnem {
		FW_FLOWC_MNEM_PFNVFN, /* PFN [15:8] VFN [7:0] */
		FW_FLOWC_MNEM_CH,

Admin message