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

Commit 6e4b51a6 authored by Hariprasad Shenai's avatar Hariprasad Shenai Committed by David S. Miller
Browse files

cxgb4/cxgb4vf/csiostor: Cleanup macros/register defines related to queues 



This patch cleanups all queue related macros/register defines that are defined
in t4fw_api.h and the affected files.

Signed-off-by: default avatarHariprasad Shenai <hariprasad@chelsio.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 5167865a

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

+58 −57
Original line number Diff line number Diff line
@@ -2299,18 +2299,18 @@ int t4_sge_alloc_rxq(struct adapter *adap, struct sge_rspq *iq, bool fwevtq, 
	memset(&c, 0, sizeof(c));

	c.op_to_vfn = htonl(FW_CMD_OP_V(FW_IQ_CMD) | FW_CMD_REQUEST_F |

			    FW_CMD_WRITE_F | FW_CMD_EXEC_F |

			    FW_IQ_CMD_PFN(adap->fn) | FW_IQ_CMD_VFN(0));

	c.alloc_to_len16 = htonl(FW_IQ_CMD_ALLOC | FW_IQ_CMD_IQSTART(1) |

			    FW_IQ_CMD_PFN_V(adap->fn) | FW_IQ_CMD_VFN_V(0));

	c.alloc_to_len16 = htonl(FW_IQ_CMD_ALLOC_F | FW_IQ_CMD_IQSTART_F |

				 FW_LEN16(c));

	c.type_to_iqandstindex = htonl(FW_IQ_CMD_TYPE(FW_IQ_TYPE_FL_INT_CAP) |

		FW_IQ_CMD_IQASYNCH(fwevtq) | FW_IQ_CMD_VIID(pi->viid) |

		FW_IQ_CMD_IQANDST(intr_idx < 0) | FW_IQ_CMD_IQANUD(1) |

		FW_IQ_CMD_IQANDSTINDEX(intr_idx >= 0 ? intr_idx :

	c.type_to_iqandstindex = htonl(FW_IQ_CMD_TYPE_V(FW_IQ_TYPE_FL_INT_CAP) |

		FW_IQ_CMD_IQASYNCH_V(fwevtq) | FW_IQ_CMD_VIID_V(pi->viid) |

		FW_IQ_CMD_IQANDST_V(intr_idx < 0) | FW_IQ_CMD_IQANUD_V(1) |

		FW_IQ_CMD_IQANDSTINDEX_V(intr_idx >= 0 ? intr_idx :

							-intr_idx - 1));

	c.iqdroprss_to_iqesize = htons(FW_IQ_CMD_IQPCIECH(pi->tx_chan) |

		FW_IQ_CMD_IQGTSMODE |

		FW_IQ_CMD_IQINTCNTTHRESH(iq->pktcnt_idx) |

		FW_IQ_CMD_IQESIZE(ilog2(iq->iqe_len) - 4));

	c.iqdroprss_to_iqesize = htons(FW_IQ_CMD_IQPCIECH_V(pi->tx_chan) |

		FW_IQ_CMD_IQGTSMODE_F |

		FW_IQ_CMD_IQINTCNTTHRESH_V(iq->pktcnt_idx) |

		FW_IQ_CMD_IQESIZE_V(ilog2(iq->iqe_len) - 4));

	c.iqsize = htons(iq->size);

	c.iqaddr = cpu_to_be64(iq->phys_addr);
@@ -2323,12 +2323,12 @@ int t4_sge_alloc_rxq(struct adapter *adap, struct sge_rspq *iq, bool fwevtq, 
			goto fl_nomem;



		flsz = fl->size / 8 + s->stat_len / sizeof(struct tx_desc);

		c.iqns_to_fl0congen = htonl(FW_IQ_CMD_FL0PACKEN(1) |

					    FW_IQ_CMD_FL0FETCHRO(1) |

					    FW_IQ_CMD_FL0DATARO(1) |

					    FW_IQ_CMD_FL0PADEN(1));

		c.fl0dcaen_to_fl0cidxfthresh = htons(FW_IQ_CMD_FL0FBMIN(2) |

				FW_IQ_CMD_FL0FBMAX(3));

		c.iqns_to_fl0congen = htonl(FW_IQ_CMD_FL0PACKEN_F |

					    FW_IQ_CMD_FL0FETCHRO_F |

					    FW_IQ_CMD_FL0DATARO_F |

					    FW_IQ_CMD_FL0PADEN_F);

		c.fl0dcaen_to_fl0cidxfthresh = htons(FW_IQ_CMD_FL0FBMIN_V(2) |

				FW_IQ_CMD_FL0FBMAX_V(3));

		c.fl0size = htons(flsz);

		c.fl0addr = cpu_to_be64(fl->addr);

	}
@@ -2425,19 +2425,20 @@ int t4_sge_alloc_eth_txq(struct adapter *adap, struct sge_eth_txq *txq, 
	memset(&c, 0, sizeof(c));

	c.op_to_vfn = htonl(FW_CMD_OP_V(FW_EQ_ETH_CMD) | FW_CMD_REQUEST_F |

			    FW_CMD_WRITE_F | FW_CMD_EXEC_F |

			    FW_EQ_ETH_CMD_PFN(adap->fn) | FW_EQ_ETH_CMD_VFN(0));

	c.alloc_to_len16 = htonl(FW_EQ_ETH_CMD_ALLOC |

				 FW_EQ_ETH_CMD_EQSTART | FW_LEN16(c));

	c.viid_pkd = htonl(FW_EQ_ETH_CMD_AUTOEQUEQE |

			   FW_EQ_ETH_CMD_VIID(pi->viid));

	c.fetchszm_to_iqid = htonl(FW_EQ_ETH_CMD_HOSTFCMODE(2) |

				   FW_EQ_ETH_CMD_PCIECHN(pi->tx_chan) |

				   FW_EQ_ETH_CMD_FETCHRO(1) |

				   FW_EQ_ETH_CMD_IQID(iqid));

	c.dcaen_to_eqsize = htonl(FW_EQ_ETH_CMD_FBMIN(2) |

				  FW_EQ_ETH_CMD_FBMAX(3) |

				  FW_EQ_ETH_CMD_CIDXFTHRESH(5) |

				  FW_EQ_ETH_CMD_EQSIZE(nentries));

			    FW_EQ_ETH_CMD_PFN_V(adap->fn) |

			    FW_EQ_ETH_CMD_VFN_V(0));

	c.alloc_to_len16 = htonl(FW_EQ_ETH_CMD_ALLOC_F |

				 FW_EQ_ETH_CMD_EQSTART_F | FW_LEN16(c));

	c.viid_pkd = htonl(FW_EQ_ETH_CMD_AUTOEQUEQE_F |

			   FW_EQ_ETH_CMD_VIID_V(pi->viid));

	c.fetchszm_to_iqid = htonl(FW_EQ_ETH_CMD_HOSTFCMODE_V(2) |

				   FW_EQ_ETH_CMD_PCIECHN_V(pi->tx_chan) |

				   FW_EQ_ETH_CMD_FETCHRO_V(1) |

				   FW_EQ_ETH_CMD_IQID_V(iqid));

	c.dcaen_to_eqsize = htonl(FW_EQ_ETH_CMD_FBMIN_V(2) |

				  FW_EQ_ETH_CMD_FBMAX_V(3) |

				  FW_EQ_ETH_CMD_CIDXFTHRESH_V(5) |

				  FW_EQ_ETH_CMD_EQSIZE_V(nentries));

	c.eqaddr = cpu_to_be64(txq->q.phys_addr);



	ret = t4_wr_mbox(adap, adap->fn, &c, sizeof(c), &c);
@@ -2451,7 +2452,7 @@ int t4_sge_alloc_eth_txq(struct adapter *adap, struct sge_eth_txq *txq, 
		return ret;

	}



	init_txq(adap, &txq->q, FW_EQ_ETH_CMD_EQID_GET(ntohl(c.eqid_pkd)));

	init_txq(adap, &txq->q, FW_EQ_ETH_CMD_EQID_G(ntohl(c.eqid_pkd)));

	txq->txq = netdevq;

	txq->tso = txq->tx_cso = txq->vlan_ins = 0;

	txq->mapping_err = 0;
@@ -2478,20 +2479,20 @@ int t4_sge_alloc_ctrl_txq(struct adapter *adap, struct sge_ctrl_txq *txq, 


	c.op_to_vfn = htonl(FW_CMD_OP_V(FW_EQ_CTRL_CMD) | FW_CMD_REQUEST_F |

			    FW_CMD_WRITE_F | FW_CMD_EXEC_F |

			    FW_EQ_CTRL_CMD_PFN(adap->fn) |

			    FW_EQ_CTRL_CMD_VFN(0));

	c.alloc_to_len16 = htonl(FW_EQ_CTRL_CMD_ALLOC |

				 FW_EQ_CTRL_CMD_EQSTART | FW_LEN16(c));

	c.cmpliqid_eqid = htonl(FW_EQ_CTRL_CMD_CMPLIQID(cmplqid));

			    FW_EQ_CTRL_CMD_PFN_V(adap->fn) |

			    FW_EQ_CTRL_CMD_VFN_V(0));

	c.alloc_to_len16 = htonl(FW_EQ_CTRL_CMD_ALLOC_F |

				 FW_EQ_CTRL_CMD_EQSTART_F | FW_LEN16(c));

	c.cmpliqid_eqid = htonl(FW_EQ_CTRL_CMD_CMPLIQID_V(cmplqid));

	c.physeqid_pkd = htonl(0);

	c.fetchszm_to_iqid = htonl(FW_EQ_CTRL_CMD_HOSTFCMODE(2) |

				   FW_EQ_CTRL_CMD_PCIECHN(pi->tx_chan) |

				   FW_EQ_CTRL_CMD_FETCHRO |

				   FW_EQ_CTRL_CMD_IQID(iqid));

	c.dcaen_to_eqsize = htonl(FW_EQ_CTRL_CMD_FBMIN(2) |

				  FW_EQ_CTRL_CMD_FBMAX(3) |

				  FW_EQ_CTRL_CMD_CIDXFTHRESH(5) |

				  FW_EQ_CTRL_CMD_EQSIZE(nentries));

	c.fetchszm_to_iqid = htonl(FW_EQ_CTRL_CMD_HOSTFCMODE_V(2) |

				   FW_EQ_CTRL_CMD_PCIECHN_V(pi->tx_chan) |

				   FW_EQ_CTRL_CMD_FETCHRO_F |

				   FW_EQ_CTRL_CMD_IQID_V(iqid));

	c.dcaen_to_eqsize = htonl(FW_EQ_CTRL_CMD_FBMIN_V(2) |

				  FW_EQ_CTRL_CMD_FBMAX_V(3) |

				  FW_EQ_CTRL_CMD_CIDXFTHRESH_V(5) |

				  FW_EQ_CTRL_CMD_EQSIZE_V(nentries));

	c.eqaddr = cpu_to_be64(txq->q.phys_addr);



	ret = t4_wr_mbox(adap, adap->fn, &c, sizeof(c), &c);
@@ -2503,7 +2504,7 @@ int t4_sge_alloc_ctrl_txq(struct adapter *adap, struct sge_ctrl_txq *txq, 
		return ret;

	}



	init_txq(adap, &txq->q, FW_EQ_CTRL_CMD_EQID_GET(ntohl(c.cmpliqid_eqid)));

	init_txq(adap, &txq->q, FW_EQ_CTRL_CMD_EQID_G(ntohl(c.cmpliqid_eqid)));

	txq->adap = adap;

	skb_queue_head_init(&txq->sendq);

	tasklet_init(&txq->qresume_tsk, restart_ctrlq, (unsigned long)txq);
@@ -2532,18 +2533,18 @@ int t4_sge_alloc_ofld_txq(struct adapter *adap, struct sge_ofld_txq *txq, 
	memset(&c, 0, sizeof(c));

	c.op_to_vfn = htonl(FW_CMD_OP_V(FW_EQ_OFLD_CMD) | FW_CMD_REQUEST_F |

			    FW_CMD_WRITE_F | FW_CMD_EXEC_F |

			    FW_EQ_OFLD_CMD_PFN(adap->fn) |

			    FW_EQ_OFLD_CMD_VFN(0));

	c.alloc_to_len16 = htonl(FW_EQ_OFLD_CMD_ALLOC |

				 FW_EQ_OFLD_CMD_EQSTART | FW_LEN16(c));

	c.fetchszm_to_iqid = htonl(FW_EQ_OFLD_CMD_HOSTFCMODE(2) |

				   FW_EQ_OFLD_CMD_PCIECHN(pi->tx_chan) |

				   FW_EQ_OFLD_CMD_FETCHRO(1) |

				   FW_EQ_OFLD_CMD_IQID(iqid));

	c.dcaen_to_eqsize = htonl(FW_EQ_OFLD_CMD_FBMIN(2) |

				  FW_EQ_OFLD_CMD_FBMAX(3) |

				  FW_EQ_OFLD_CMD_CIDXFTHRESH(5) |

				  FW_EQ_OFLD_CMD_EQSIZE(nentries));

			    FW_EQ_OFLD_CMD_PFN_V(adap->fn) |

			    FW_EQ_OFLD_CMD_VFN_V(0));

	c.alloc_to_len16 = htonl(FW_EQ_OFLD_CMD_ALLOC_F |

				 FW_EQ_OFLD_CMD_EQSTART_F | FW_LEN16(c));

	c.fetchszm_to_iqid = htonl(FW_EQ_OFLD_CMD_HOSTFCMODE_V(2) |

				   FW_EQ_OFLD_CMD_PCIECHN_V(pi->tx_chan) |

				   FW_EQ_OFLD_CMD_FETCHRO_F |

				   FW_EQ_OFLD_CMD_IQID_V(iqid));

	c.dcaen_to_eqsize = htonl(FW_EQ_OFLD_CMD_FBMIN_V(2) |

				  FW_EQ_OFLD_CMD_FBMAX_V(3) |

				  FW_EQ_OFLD_CMD_CIDXFTHRESH_V(5) |

				  FW_EQ_OFLD_CMD_EQSIZE_V(nentries));

	c.eqaddr = cpu_to_be64(txq->q.phys_addr);



	ret = t4_wr_mbox(adap, adap->fn, &c, sizeof(c), &c);
@@ -2557,7 +2558,7 @@ int t4_sge_alloc_ofld_txq(struct adapter *adap, struct sge_ofld_txq *txq, 
		return ret;

	}



	init_txq(adap, &txq->q, FW_EQ_OFLD_CMD_EQID_GET(ntohl(c.eqid_pkd)));

	init_txq(adap, &txq->q, FW_EQ_OFLD_CMD_EQID_G(ntohl(c.eqid_pkd)));

	txq->adap = adap;

	skb_queue_head_init(&txq->sendq);

	tasklet_init(&txq->qresume_tsk, restart_ofldq, (unsigned long)txq);

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

+16 −16
Original line number Diff line number Diff line
@@ -3715,10 +3715,10 @@ int t4_iq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, 


	memset(&c, 0, sizeof(c));

	c.op_to_vfn = htonl(FW_CMD_OP_V(FW_IQ_CMD) | FW_CMD_REQUEST_F |

			    FW_CMD_EXEC_F | FW_IQ_CMD_PFN(pf) |

			    FW_IQ_CMD_VFN(vf));

	c.alloc_to_len16 = htonl(FW_IQ_CMD_FREE | FW_LEN16(c));

	c.type_to_iqandstindex = htonl(FW_IQ_CMD_TYPE(iqtype));

			    FW_CMD_EXEC_F | FW_IQ_CMD_PFN_V(pf) |

			    FW_IQ_CMD_VFN_V(vf));

	c.alloc_to_len16 = htonl(FW_IQ_CMD_FREE_F | FW_LEN16(c));

	c.type_to_iqandstindex = htonl(FW_IQ_CMD_TYPE_V(iqtype));

	c.iqid = htons(iqid);

	c.fl0id = htons(fl0id);

	c.fl1id = htons(fl1id);
@@ -3742,10 +3742,10 @@ int t4_eth_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, 


	memset(&c, 0, sizeof(c));

	c.op_to_vfn = htonl(FW_CMD_OP_V(FW_EQ_ETH_CMD) | FW_CMD_REQUEST_F |

			    FW_CMD_EXEC_F | FW_EQ_ETH_CMD_PFN(pf) |

			    FW_EQ_ETH_CMD_VFN(vf));

	c.alloc_to_len16 = htonl(FW_EQ_ETH_CMD_FREE | FW_LEN16(c));

	c.eqid_pkd = htonl(FW_EQ_ETH_CMD_EQID(eqid));

			    FW_CMD_EXEC_F | FW_EQ_ETH_CMD_PFN_V(pf) |

			    FW_EQ_ETH_CMD_VFN_V(vf));

	c.alloc_to_len16 = htonl(FW_EQ_ETH_CMD_FREE_F | FW_LEN16(c));

	c.eqid_pkd = htonl(FW_EQ_ETH_CMD_EQID_V(eqid));

	return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);

}
@@ -3766,10 +3766,10 @@ int t4_ctrl_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, 


	memset(&c, 0, sizeof(c));

	c.op_to_vfn = htonl(FW_CMD_OP_V(FW_EQ_CTRL_CMD) | FW_CMD_REQUEST_F |

			    FW_CMD_EXEC_F | FW_EQ_CTRL_CMD_PFN(pf) |

			    FW_EQ_CTRL_CMD_VFN(vf));

	c.alloc_to_len16 = htonl(FW_EQ_CTRL_CMD_FREE | FW_LEN16(c));

	c.cmpliqid_eqid = htonl(FW_EQ_CTRL_CMD_EQID(eqid));

			    FW_CMD_EXEC_F | FW_EQ_CTRL_CMD_PFN_V(pf) |

			    FW_EQ_CTRL_CMD_VFN_V(vf));

	c.alloc_to_len16 = htonl(FW_EQ_CTRL_CMD_FREE_F | FW_LEN16(c));

	c.cmpliqid_eqid = htonl(FW_EQ_CTRL_CMD_EQID_V(eqid));

	return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);

}
@@ -3790,10 +3790,10 @@ int t4_ofld_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, 


	memset(&c, 0, sizeof(c));

	c.op_to_vfn = htonl(FW_CMD_OP_V(FW_EQ_OFLD_CMD) | FW_CMD_REQUEST_F |

			    FW_CMD_EXEC_F | FW_EQ_OFLD_CMD_PFN(pf) |

			    FW_EQ_OFLD_CMD_VFN(vf));

	c.alloc_to_len16 = htonl(FW_EQ_OFLD_CMD_FREE | FW_LEN16(c));

	c.eqid_pkd = htonl(FW_EQ_OFLD_CMD_EQID(eqid));

			    FW_CMD_EXEC_F | FW_EQ_OFLD_CMD_PFN_V(pf) |

			    FW_EQ_OFLD_CMD_VFN_V(vf));

	c.alloc_to_len16 = htonl(FW_EQ_OFLD_CMD_FREE_F | FW_LEN16(c));

	c.eqid_pkd = htonl(FW_EQ_OFLD_CMD_EQID_V(eqid));

	return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);

}

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

+514 −176

File changed.

Preview size limit exceeded, changes collapsed.

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

+32 −31
Original line number Diff line number Diff line
@@ -2092,22 +2092,22 @@ int t4vf_sge_alloc_rxq(struct adapter *adapter, struct sge_rspq *rspq, 
				    FW_CMD_REQUEST_F |

				    FW_CMD_WRITE_F |

				    FW_CMD_EXEC_F);

	cmd.alloc_to_len16 = cpu_to_be32(FW_IQ_CMD_ALLOC |

					 FW_IQ_CMD_IQSTART(1) |

	cmd.alloc_to_len16 = cpu_to_be32(FW_IQ_CMD_ALLOC_F |

					 FW_IQ_CMD_IQSTART_F |

					 FW_LEN16(cmd));

	cmd.type_to_iqandstindex =

		cpu_to_be32(FW_IQ_CMD_TYPE(FW_IQ_TYPE_FL_INT_CAP) |

			    FW_IQ_CMD_IQASYNCH(iqasynch) |

			    FW_IQ_CMD_VIID(pi->viid) |

			    FW_IQ_CMD_IQANDST(iqandst) |

			    FW_IQ_CMD_IQANUS(1) |

			    FW_IQ_CMD_IQANUD(SGE_UPDATEDEL_INTR) |

			    FW_IQ_CMD_IQANDSTINDEX(intr_dest));

		cpu_to_be32(FW_IQ_CMD_TYPE_V(FW_IQ_TYPE_FL_INT_CAP) |

			    FW_IQ_CMD_IQASYNCH_V(iqasynch) |

			    FW_IQ_CMD_VIID_V(pi->viid) |

			    FW_IQ_CMD_IQANDST_V(iqandst) |

			    FW_IQ_CMD_IQANUS_V(1) |

			    FW_IQ_CMD_IQANUD_V(SGE_UPDATEDEL_INTR) |

			    FW_IQ_CMD_IQANDSTINDEX_V(intr_dest));

	cmd.iqdroprss_to_iqesize =

		cpu_to_be16(FW_IQ_CMD_IQPCIECH(pi->port_id) |

			    FW_IQ_CMD_IQGTSMODE |

			    FW_IQ_CMD_IQINTCNTTHRESH(rspq->pktcnt_idx) |

			    FW_IQ_CMD_IQESIZE(ilog2(rspq->iqe_len) - 4));

		cpu_to_be16(FW_IQ_CMD_IQPCIECH_V(pi->port_id) |

			    FW_IQ_CMD_IQGTSMODE_F |

			    FW_IQ_CMD_IQINTCNTTHRESH_V(rspq->pktcnt_idx) |

			    FW_IQ_CMD_IQESIZE_V(ilog2(rspq->iqe_len) - 4));

	cmd.iqsize = cpu_to_be16(rspq->size);

	cmd.iqaddr = cpu_to_be64(rspq->phys_addr);
@@ -2141,13 +2141,13 @@ int t4vf_sge_alloc_rxq(struct adapter *adapter, struct sge_rspq *rspq, 
		 */

		cmd.iqns_to_fl0congen =

			cpu_to_be32(

				FW_IQ_CMD_FL0HOSTFCMODE(SGE_HOSTFCMODE_NONE) |

				FW_IQ_CMD_FL0PACKEN(1) |

				FW_IQ_CMD_FL0PADEN(1));

				FW_IQ_CMD_FL0HOSTFCMODE_V(SGE_HOSTFCMODE_NONE) |

				FW_IQ_CMD_FL0PACKEN_F |

				FW_IQ_CMD_FL0PADEN_F);

		cmd.fl0dcaen_to_fl0cidxfthresh =

			cpu_to_be16(

				FW_IQ_CMD_FL0FBMIN(SGE_FETCHBURSTMIN_64B) |

				FW_IQ_CMD_FL0FBMAX(SGE_FETCHBURSTMAX_512B));

				FW_IQ_CMD_FL0FBMIN_V(SGE_FETCHBURSTMIN_64B) |

				FW_IQ_CMD_FL0FBMAX_V(SGE_FETCHBURSTMAX_512B));

		cmd.fl0size = cpu_to_be16(flsz);

		cmd.fl0addr = cpu_to_be64(fl->addr);

	}
@@ -2255,20 +2255,21 @@ int t4vf_sge_alloc_eth_txq(struct adapter *adapter, struct sge_eth_txq *txq, 
				    FW_CMD_REQUEST_F |

				    FW_CMD_WRITE_F |

				    FW_CMD_EXEC_F);

	cmd.alloc_to_len16 = cpu_to_be32(FW_EQ_ETH_CMD_ALLOC |

					 FW_EQ_ETH_CMD_EQSTART |

	cmd.alloc_to_len16 = cpu_to_be32(FW_EQ_ETH_CMD_ALLOC_F |

					 FW_EQ_ETH_CMD_EQSTART_F |

					 FW_LEN16(cmd));

	cmd.viid_pkd = cpu_to_be32(FW_EQ_ETH_CMD_AUTOEQUEQE |

				   FW_EQ_ETH_CMD_VIID(pi->viid));

	cmd.viid_pkd = cpu_to_be32(FW_EQ_ETH_CMD_AUTOEQUEQE_F |

				   FW_EQ_ETH_CMD_VIID_V(pi->viid));

	cmd.fetchszm_to_iqid =

		cpu_to_be32(FW_EQ_ETH_CMD_HOSTFCMODE(SGE_HOSTFCMODE_STPG) |

			    FW_EQ_ETH_CMD_PCIECHN(pi->port_id) |

			    FW_EQ_ETH_CMD_IQID(iqid));

		cpu_to_be32(FW_EQ_ETH_CMD_HOSTFCMODE_V(SGE_HOSTFCMODE_STPG) |

			    FW_EQ_ETH_CMD_PCIECHN_V(pi->port_id) |

			    FW_EQ_ETH_CMD_IQID_V(iqid));

	cmd.dcaen_to_eqsize =

		cpu_to_be32(FW_EQ_ETH_CMD_FBMIN(SGE_FETCHBURSTMIN_64B) |

			    FW_EQ_ETH_CMD_FBMAX(SGE_FETCHBURSTMAX_512B) |

			    FW_EQ_ETH_CMD_CIDXFTHRESH(SGE_CIDXFLUSHTHRESH_32) |

			    FW_EQ_ETH_CMD_EQSIZE(nentries));

		cpu_to_be32(FW_EQ_ETH_CMD_FBMIN_V(SGE_FETCHBURSTMIN_64B) |

			    FW_EQ_ETH_CMD_FBMAX_V(SGE_FETCHBURSTMAX_512B) |

			    FW_EQ_ETH_CMD_CIDXFTHRESH_V(

						SGE_CIDXFLUSHTHRESH_32) |

			    FW_EQ_ETH_CMD_EQSIZE_V(nentries));

	cmd.eqaddr = cpu_to_be64(txq->q.phys_addr);



	/*
@@ -2294,9 +2295,9 @@ int t4vf_sge_alloc_eth_txq(struct adapter *adapter, struct sge_eth_txq *txq, 
	txq->q.cidx = 0;

	txq->q.pidx = 0;

	txq->q.stat = (void *)&txq->q.desc[txq->q.size];

	txq->q.cntxt_id = FW_EQ_ETH_CMD_EQID_GET(be32_to_cpu(rpl.eqid_pkd));

	txq->q.cntxt_id = FW_EQ_ETH_CMD_EQID_G(be32_to_cpu(rpl.eqid_pkd));

	txq->q.abs_id =

		FW_EQ_ETH_CMD_PHYSEQID_GET(be32_to_cpu(rpl.physeqid_pkd));

		FW_EQ_ETH_CMD_PHYSEQID_G(be32_to_cpu(rpl.physeqid_pkd));

	txq->txq = devq;

	txq->tso = 0;

	txq->tx_cso = 0;

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

+4 −4
Original line number Diff line number Diff line
@@ -1302,10 +1302,10 @@ int t4vf_iq_free(struct adapter *adapter, unsigned int iqtype, 
	cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_IQ_CMD) |

				    FW_CMD_REQUEST_F |

				    FW_CMD_EXEC_F);

	cmd.alloc_to_len16 = cpu_to_be32(FW_IQ_CMD_FREE |

	cmd.alloc_to_len16 = cpu_to_be32(FW_IQ_CMD_FREE_F |

					 FW_LEN16(cmd));

	cmd.type_to_iqandstindex =

		cpu_to_be32(FW_IQ_CMD_TYPE(iqtype));

		cpu_to_be32(FW_IQ_CMD_TYPE_V(iqtype));



	cmd.iqid = cpu_to_be16(iqid);

	cmd.fl0id = cpu_to_be16(fl0id);
@@ -1328,9 +1328,9 @@ int t4vf_eth_eq_free(struct adapter *adapter, unsigned int eqid) 
	cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_EQ_ETH_CMD) |

				    FW_CMD_REQUEST_F |

				    FW_CMD_EXEC_F);

	cmd.alloc_to_len16 = cpu_to_be32(FW_EQ_ETH_CMD_FREE |

	cmd.alloc_to_len16 = cpu_to_be32(FW_EQ_ETH_CMD_FREE_F |

					 FW_LEN16(cmd));

	cmd.eqid_pkd = cpu_to_be32(FW_EQ_ETH_CMD_EQID(eqid));

	cmd.eqid_pkd = cpu_to_be32(FW_EQ_ETH_CMD_EQID_V(eqid));

	return t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), NULL);

}