Merge branch 'cxgb4-next' (7ee81365) · Commits · e / devices / android_kernel_teracube_emerald

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

+22 −3

Original line number	Diff line number	Diff line
		@@ -222,6 +222,12 @@ struct tp_err_stats {
		u32 ofldCongDefer;
		};

		struct sge_params {
		u32 hps; /* host page size for our PF/VF */
		u32 eq_qpp; /* egress queues/page for our PF/VF */
		u32 iq_qpp; /* egress queues/page for our PF/VF */
		};

		struct tp_params {
		unsigned int ntxchan; /* # of Tx channels */
		unsigned int tre; /* log2 of core clocks per TP tick */
		@@ -285,6 +291,7 @@ enum chip_type {
		};

		struct adapter_params {
		struct sge_params sge;
		struct tp_params tp;
		struct vpd_params vpd;
		struct pci_params pci;
		@@ -431,7 +438,8 @@ struct sge_fl { /* SGE free-buffer queue state */
		struct rx_sw_desc sdesc; / address of SW Rx descriptor ring */
		__be64 desc; / address of HW Rx descriptor ring */
		dma_addr_t addr; /* bus address of HW ring start */
		u64 udb; /* BAR2 offset of User Doorbell area */
		void __iomem bar2_addr; / address of BAR2 Queue registers */
		unsigned int bar2_qid; /* Queue ID for BAR2 Queue registers */
		};

		/* A packet gather list */
		@@ -461,7 +469,8 @@ struct sge_rspq { /* state for an SGE response queue */
		u16 abs_id; /* absolute SGE id for the response q */
		__be64 desc; / address of HW response ring */
		dma_addr_t phys_addr; /* physical address of the ring */
		u64 udb; /* BAR2 offset of User Doorbell area */
		void __iomem bar2_addr; / address of BAR2 Queue registers */
		unsigned int bar2_qid; /* Queue ID for BAR2 Queue registers */
		unsigned int iqe_len; /* entry size */
		unsigned int size; /* capacity of response queue */
		struct adapter *adap;
		@@ -519,7 +528,8 @@ struct sge_txq {
		int db_disabled;
		unsigned short db_pidx;
		unsigned short db_pidx_inc;
		u64 udb; /* BAR2 offset of User Doorbell area */
		void __iomem bar2_addr; / address of BAR2 Queue registers */
		unsigned int bar2_qid; /* Queue ID for BAR2 Queue registers */
		};

		struct sge_eth_txq { /* state for an SGE Ethernet Tx queue */
		@@ -995,6 +1005,15 @@ int t4_prep_fw(struct adapter adap, struct fw_info fw_info,
		const u8 *fw_data, unsigned int fw_size,
		struct fw_hdr card_fw, enum dev_state state, int reset);
		int t4_prep_adapter(struct adapter *adapter);

		enum t4_bar2_qtype { T4_BAR2_QTYPE_EGRESS, T4_BAR2_QTYPE_INGRESS };
		int t4_bar2_sge_qregs(struct adapter *adapter,
		unsigned int qid,
		enum t4_bar2_qtype qtype,
		u64 *pbar2_qoffset,
		unsigned int *pbar2_qid);

		int t4_init_sge_params(struct adapter *adapter);
		int t4_init_tp_params(struct adapter *adap);
		int t4_filter_field_shift(const struct adapter *adap, int filter_sel);
		int t4_port_init(struct adapter *adap, int mbox, int pf, int vf);

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

+30 −30

Original line number	Diff line number	Diff line
		@@ -3805,6 +3805,22 @@ u64 cxgb4_read_sge_timestamp(struct net_device *dev)
		}
		EXPORT_SYMBOL(cxgb4_read_sge_timestamp);

		int cxgb4_bar2_sge_qregs(struct net_device *dev,
		unsigned int qid,
		enum cxgb4_bar2_qtype qtype,
		u64 *pbar2_qoffset,
		unsigned int *pbar2_qid)
		{
		return t4_bar2_sge_qregs(netdev2adap(dev),
		qid,
		(qtype == CXGB4_BAR2_QTYPE_EGRESS
		? T4_BAR2_QTYPE_EGRESS
		: T4_BAR2_QTYPE_INGRESS),
		pbar2_qoffset,
		pbar2_qid);
		}
		EXPORT_SYMBOL(cxgb4_bar2_sge_qregs);

		static struct pci_driver cxgb4_driver;

		static void check_neigh_update(struct neighbour *neigh)
		@@ -3987,31 +4003,18 @@ static void process_db_drop(struct work_struct *work)
		u32 dropped_db = t4_read_reg(adap, 0x010ac);
		u16 qid = (dropped_db >> 15) & 0x1ffff;
		u16 pidx_inc = dropped_db & 0x1fff;
		unsigned int s_qpp;
		unsigned short udb_density;
		unsigned long qpshift;
		int page;
		u32 udb;

		dev_warn(adap->pdev_dev,
		"Dropped DB 0x%x qid %d bar2 %d coalesce %d pidx %d\n",
		dropped_db, qid,
		(dropped_db >> 14) & 1,
		(dropped_db >> 13) & 1,
		pidx_inc);

		drain_db_fifo(adap, 1);

		s_qpp = QUEUESPERPAGEPF1 * adap->fn;
		udb_density = 1 << QUEUESPERPAGEPF0_GET(t4_read_reg(adap,
		SGE_EGRESS_QUEUES_PER_PAGE_PF) >> s_qpp);
		qpshift = PAGE_SHIFT - ilog2(udb_density);
		udb = qid << qpshift;
		udb &= PAGE_MASK;
		page = udb / PAGE_SIZE;
		udb += (qid - (page * udb_density)) * 128;
		u64 bar2_qoffset;
		unsigned int bar2_qid;
		int ret;

		writel(PIDX(pidx_inc), adap->bar2 + udb + 8);
		ret = t4_bar2_sge_qregs(adap, qid, T4_BAR2_QTYPE_EGRESS,
		&bar2_qoffset, &bar2_qid);
		if (ret)
		dev_err(adap->pdev_dev, "doorbell drop recovery: "
		"qid=%d, pidx_inc=%d\n", qid, pidx_inc);
		else
		writel(PIDX_T5(pidx_inc) \| QID(bar2_qid),
		adap->bar2 + bar2_qoffset + SGE_UDB_KDOORBELL);

		/* Re-enable BAR2 WC */
		t4_set_reg_field(adap, 0x10b0, 1<<15, 1<<15);
		@@ -4069,12 +4072,8 @@ static void uld_attach(struct adapter *adap, unsigned int uld)
		lli.adapter_type = adap->params.chip;
		lli.iscsi_iolen = MAXRXDATA_GET(t4_read_reg(adap, TP_PARA_REG2));
		lli.cclk_ps = 1000000000 / adap->params.vpd.cclk;
		lli.udb_density = 1 << QUEUESPERPAGEPF0_GET(
		t4_read_reg(adap, SGE_EGRESS_QUEUES_PER_PAGE_PF) >>
		(adap->fn * 4));
		lli.ucq_density = 1 << QUEUESPERPAGEPF0_GET(
		t4_read_reg(adap, SGE_INGRESS_QUEUES_PER_PAGE_PF) >>
		(adap->fn * 4));
		lli.udb_density = 1 << adap->params.sge.eq_qpp;
		lli.ucq_density = 1 << adap->params.sge.iq_qpp;
		lli.filt_mode = adap->params.tp.vlan_pri_map;
		/* MODQ_REQ_MAP sets queues 0-3 to chan 0-3 */
		for (i = 0; i < NCHAN; i++)
		@@ -5926,6 +5925,7 @@ static int adap_init0(struct adapter *adap)
		t4_load_mtus(adap, adap->params.mtus, adap->params.a_wnd,
		adap->params.b_wnd);
		}
		t4_init_sge_params(adap);
		t4_init_tp_params(adap);
		adap->flags \|= FW_OK;
		return 0;

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

+7 −0

Original line number	Diff line number	Diff line
		@@ -305,4 +305,11 @@ void cxgb4_enable_db_coalescing(struct net_device *dev);
		int cxgb4_read_tpte(struct net_device dev, u32 stag, __be32 tpte);
		u64 cxgb4_read_sge_timestamp(struct net_device *dev);

		enum cxgb4_bar2_qtype { CXGB4_BAR2_QTYPE_EGRESS, CXGB4_BAR2_QTYPE_INGRESS };
		int cxgb4_bar2_sge_qregs(struct net_device *dev,
		unsigned int qid,
		enum cxgb4_bar2_qtype qtype,
		u64 *pbar2_qoffset,
		unsigned int *pbar2_qid);

		#endif /* !__CXGB4_OFLD_H */

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

+76 −72

Original line number	Diff line number	Diff line
		@@ -527,14 +527,16 @@ static inline void ring_fl_db(struct adapter adap, struct sge_fl q)
		val \|= DBPRIO(1);
		wmb();

		/* If we're on T4, use the old doorbell mechanism; otherwise
		* use the new BAR2 mechanism.
		/* If we don't have access to the new User Doorbell (T5+), use
		* the old doorbell mechanism; otherwise use the new BAR2
		* mechanism.
		*/
		if (is_t4(adap->params.chip)) {
		if (unlikely(q->bar2_addr == NULL)) {
		t4_write_reg(adap, MYPF_REG(SGE_PF_KDOORBELL),
		val \| QID(q->cntxt_id));
		} else {
		writel(val, adap->bar2 + q->udb + SGE_UDB_KDOORBELL);
		writel(val \| QID(q->bar2_qid),
		q->bar2_addr + SGE_UDB_KDOORBELL);

		/* This Write memory Barrier will force the write to
		* the User Doorbell area to be flushed.
		@@ -850,14 +852,13 @@ static void write_sgl(const struct sk_buff skb, struct sge_txq q,
		*end = 0;
		}

		/* This function copies a tx_desc struct to memory mapped BAR2 space(user space
		* writes). For coalesced WR SGE, fetches data from the FIFO instead of from
		* Host.
		/* This function copies 64 byte coalesced work request to
		* memory mapped BAR2 space. For coalesced WR SGE fetches
		* data from the FIFO instead of from Host.
		*/
		static void cxgb_pio_copy(u64 __iomem dst, struct tx_desc desc)
		static void cxgb_pio_copy(u64 __iomem dst, u64 src)
		{
		int count = sizeof(*desc) / sizeof(u64);
		u64 src = (u64 )desc;
		int count = 8;

		while (count) {
		writeq(*src, dst);
		@@ -879,7 +880,10 @@ static inline void ring_tx_db(struct adapter adap, struct sge_txq q, int n)
		{
		wmb(); /* write descriptors before telling HW */

		if (is_t4(adap->params.chip)) {
		/* If we don't have access to the new User Doorbell (T5+), use the old
		* doorbell mechanism; otherwise use the new BAR2 mechanism.
		*/
		if (unlikely(q->bar2_addr == NULL)) {
		u32 val = PIDX(n);
		unsigned long flags;

		@@ -905,21 +909,22 @@ static inline void ring_tx_db(struct adapter adap, struct sge_txq q, int n)
		*/
		WARN_ON(val & DBPRIO(1));

		/* For T5 and later we use the Write-Combine mapped BAR2 User
		* Doorbell mechanism. If we're only writing a single TX
		* Descriptor and TX Write Combining hasn't been disabled, we
		* can use the Write Combining Gather Buffer; otherwise we use
		* the simple doorbell.
		/* If we're only writing a single TX Descriptor and we can use
		* Inferred QID registers, we can use the Write Combining
		* Gather Buffer; otherwise we use the simple doorbell.
		*/
		if (n == 1) {
		if (n == 1 && q->bar2_qid == 0) {
		int index = (q->pidx
		? (q->pidx - 1)
		: (q->size - 1));
		u64 wr = (u64 )&q->desc[index];

		cxgb_pio_copy(adap->bar2 + q->udb + SGE_UDB_WCDOORBELL,
		q->desc + index);
		cxgb_pio_copy((u64 __iomem *)
		(q->bar2_addr + SGE_UDB_WCDOORBELL),
		wr);
		} else {
		writel(val, adap->bar2 + q->udb + SGE_UDB_KDOORBELL);
		writel(val \| QID(q->bar2_qid),
		q->bar2_addr + SGE_UDB_KDOORBELL);
		}

		/* This Write Memory Barrier will force the write to the User
		@@ -1997,11 +2002,16 @@ static int napi_rx_handler(struct napi_struct *napi, int budget)
		params = QINTR_TIMER_IDX(7);

		val = CIDXINC(work_done) \| SEINTARM(params);
		if (is_t4(q->adap->params.chip)) {

		/* If we don't have access to the new User GTS (T5+), use the old
		* doorbell mechanism; otherwise use the new BAR2 mechanism.
		*/
		if (unlikely(q->bar2_addr == NULL)) {
		t4_write_reg(q->adap, MYPF_REG(SGE_PF_GTS),
		val \| INGRESSQID((u32)q->cntxt_id));
		} else {
		writel(val, q->adap->bar2 + q->udb + SGE_UDB_GTS);
		writel(val \| INGRESSQID(q->bar2_qid),
		q->bar2_addr + SGE_UDB_GTS);
		wmb();
		}
		return work_done;
		@@ -2047,11 +2057,16 @@ static unsigned int process_intrq(struct adapter *adap)
		}

		val = CIDXINC(credits) \| SEINTARM(q->intr_params);
		if (is_t4(adap->params.chip)) {

		/* If we don't have access to the new User GTS (T5+), use the old
		* doorbell mechanism; otherwise use the new BAR2 mechanism.
		*/
		if (unlikely(q->bar2_addr == NULL)) {
		t4_write_reg(adap, MYPF_REG(SGE_PF_GTS),
		val \| INGRESSQID(q->cntxt_id));
		} else {
		writel(val, adap->bar2 + q->udb + SGE_UDB_GTS);
		writel(val \| INGRESSQID(q->bar2_qid),
		q->bar2_addr + SGE_UDB_GTS);
		wmb();
		}
		spin_unlock(&adap->sge.intrq_lock);
		@@ -2235,48 +2250,32 @@ static void sge_tx_timer_cb(unsigned long data)
		}

		/**
		* udb_address - return the BAR2 User Doorbell address for a Queue
		* @adap: the adapter
		* @cntxt_id: the Queue Context ID
		* @qpp: Queues Per Page (for all PFs)
		*
		* Returns the BAR2 address of the user Doorbell associated with the
		* indicated Queue Context ID. Note that this is only applicable
		* for T5 and later.
		*/
		static u64 udb_address(struct adapter *adap, unsigned int cntxt_id,
		unsigned int qpp)
		{
		u64 udb;
		unsigned int s_qpp;
		unsigned short udb_density;
		unsigned long qpshift;
		int page;

		BUG_ON(is_t4(adap->params.chip));

		s_qpp = (QUEUESPERPAGEPF0 +
		(QUEUESPERPAGEPF1 - QUEUESPERPAGEPF0) * adap->fn);
		udb_density = 1 << ((qpp >> s_qpp) & QUEUESPERPAGEPF0_MASK);
		qpshift = PAGE_SHIFT - ilog2(udb_density);
		udb = (u64)cntxt_id << qpshift;
		udb &= PAGE_MASK;
		page = udb / PAGE_SIZE;
		udb += (cntxt_id - (page * udb_density)) * SGE_UDB_SIZE;

		return udb;
		}
		* bar2_address - return the BAR2 address for an SGE Queue's Registers
		* @adapter: the adapter
		* @qid: the SGE Queue ID
		* @qtype: the SGE Queue Type (Egress or Ingress)
		* @pbar2_qid: BAR2 Queue ID or 0 for Queue ID inferred SGE Queues
		*
		* Returns the BAR2 address for the SGE Queue Registers associated with
		* @qid. If BAR2 SGE Registers aren't available, returns NULL. Also
		* returns the BAR2 Queue ID to be used with writes to the BAR2 SGE
		* Queue Registers. If the BAR2 Queue ID is 0, then "Inferred Queue ID"
		* Registers are supported (e.g. the Write Combining Doorbell Buffer).
		*/
		static void __iomem bar2_address(struct adapter adapter,
		unsigned int qid,
		enum t4_bar2_qtype qtype,
		unsigned int *pbar2_qid)
		{
		u64 bar2_qoffset;
		int ret;

		static u64 udb_address_eq(struct adapter *adap, unsigned int cntxt_id)
		{
		return udb_address(adap, cntxt_id,
		t4_read_reg(adap, SGE_EGRESS_QUEUES_PER_PAGE_PF));
		}
		ret = t4_bar2_sge_qregs(adapter, qid, qtype,
		&bar2_qoffset, pbar2_qid);
		if (ret)
		return NULL;

		static u64 udb_address_iq(struct adapter *adap, unsigned int cntxt_id)
		{
		return udb_address(adap, cntxt_id,
		t4_read_reg(adap, SGE_INGRESS_QUEUES_PER_PAGE_PF));
		return adapter->bar2 + bar2_qoffset;
		}

		int t4_sge_alloc_rxq(struct adapter adap, struct sge_rspq iq, bool fwevtq,
		@@ -2344,8 +2343,10 @@ int t4_sge_alloc_rxq(struct adapter adap, struct sge_rspq iq, bool fwevtq,
		iq->next_intr_params = iq->intr_params;
		iq->cntxt_id = ntohs(c.iqid);
		iq->abs_id = ntohs(c.physiqid);
		if (!is_t4(adap->params.chip))
		iq->udb = udb_address_iq(adap, iq->cntxt_id);
		iq->bar2_addr = bar2_address(adap,
		iq->cntxt_id,
		T4_BAR2_QTYPE_INGRESS,
		&iq->bar2_qid);
		iq->size--; /* subtract status entry */
		iq->netdev = dev;
		iq->handler = hnd;
		@@ -2362,11 +2363,13 @@ int t4_sge_alloc_rxq(struct adapter adap, struct sge_rspq iq, bool fwevtq,
		fl->alloc_failed = fl->large_alloc_failed = fl->starving = 0;
		adap->sge.egr_map[fl->cntxt_id - adap->sge.egr_start] = fl;

		/* Note, we must initialize the Free List User Doorbell
		* address before refilling the Free List!
		/* Note, we must initialize the BAR2 Free List User Doorbell
		* information before refilling the Free List!
		*/
		if (!is_t4(adap->params.chip))
		fl->udb = udb_address_eq(adap, fl->cntxt_id);
		fl->bar2_addr = bar2_address(adap,
		fl->cntxt_id,
		T4_BAR2_QTYPE_EGRESS,
		&fl->bar2_qid);
		refill_fl(adap, fl, fl_cap(fl), GFP_KERNEL);
		}
		return 0;
		@@ -2392,9 +2395,10 @@ int t4_sge_alloc_rxq(struct adapter adap, struct sge_rspq iq, bool fwevtq,
		static void init_txq(struct adapter adap, struct sge_txq q, unsigned int id)
		{
		q->cntxt_id = id;
		if (!is_t4(adap->params.chip))
		q->udb = udb_address_eq(adap, q->cntxt_id);

		q->bar2_addr = bar2_address(adap,
		q->cntxt_id,
		T4_BAR2_QTYPE_EGRESS,
		&q->bar2_qid);
		q->in_use = 0;
		q->cidx = q->pidx = 0;
		q->stops = q->restarts = 0;

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

+122 −0

Original line number	Diff line number	Diff line
		@@ -1213,6 +1213,8 @@ int t4_load_fw(struct adapter adap, const u8 fw_data, unsigned int size)
		if (ret)
		dev_err(adap->pdev_dev, "firmware download failed, error %d\n",
		ret);
		else
		ret = t4_get_fw_version(adap, &adap->params.fw_vers);
		return ret;
		}

		@@ -4002,6 +4004,126 @@ int t4_prep_adapter(struct adapter *adapter)
		return 0;
		}

		/**
		* t4_bar2_sge_qregs - return BAR2 SGE Queue register information
		* @adapter: the adapter
		* @qid: the Queue ID
		* @qtype: the Ingress or Egress type for @qid
		* @pbar2_qoffset: BAR2 Queue Offset
		* @pbar2_qid: BAR2 Queue ID or 0 for Queue ID inferred SGE Queues
		*
		* Returns the BAR2 SGE Queue Registers information associated with the
		* indicated Absolute Queue ID. These are passed back in return value
		* pointers. @qtype should be T4_BAR2_QTYPE_EGRESS for Egress Queue
		* and T4_BAR2_QTYPE_INGRESS for Ingress Queues.
		*
		* This may return an error which indicates that BAR2 SGE Queue
		* registers aren't available. If an error is not returned, then the
		* following values are returned:
		*
		* *@pbar2_qoffset: the BAR2 Offset of the @qid Registers
		* *@pbar2_qid: the BAR2 SGE Queue ID or 0 of @qid
		*
		* If the returned BAR2 Queue ID is 0, then BAR2 SGE registers which
		* require the "Inferred Queue ID" ability may be used. E.g. the
		* Write Combining Doorbell Buffer. If the BAR2 Queue ID is not 0,
		* then these "Inferred Queue ID" register may not be used.
		*/
		int t4_bar2_sge_qregs(struct adapter *adapter,
		unsigned int qid,
		enum t4_bar2_qtype qtype,
		u64 *pbar2_qoffset,
		unsigned int *pbar2_qid)
		{
		unsigned int page_shift, page_size, qpp_shift, qpp_mask;
		u64 bar2_page_offset, bar2_qoffset;
		unsigned int bar2_qid, bar2_qid_offset, bar2_qinferred;

		/* T4 doesn't support BAR2 SGE Queue registers.
		*/
		if (is_t4(adapter->params.chip))
		return -EINVAL;

		/* Get our SGE Page Size parameters.
		*/
		page_shift = adapter->params.sge.hps + 10;
		page_size = 1 << page_shift;

		/* Get the right Queues per Page parameters for our Queue.
		*/
		qpp_shift = (qtype == T4_BAR2_QTYPE_EGRESS
		? adapter->params.sge.eq_qpp
		: adapter->params.sge.iq_qpp);
		qpp_mask = (1 << qpp_shift) - 1;

		/* Calculate the basics of the BAR2 SGE Queue register area:
		* o The BAR2 page the Queue registers will be in.
		* o The BAR2 Queue ID.
		* o The BAR2 Queue ID Offset into the BAR2 page.
		*/
		bar2_page_offset = ((qid >> qpp_shift) << page_shift);
		bar2_qid = qid & qpp_mask;
		bar2_qid_offset = bar2_qid * SGE_UDB_SIZE;

		/* If the BAR2 Queue ID Offset is less than the Page Size, then the
		* hardware will infer the Absolute Queue ID simply from the writes to
		* the BAR2 Queue ID Offset within the BAR2 Page (and we need to use a
		* BAR2 Queue ID of 0 for those writes). Otherwise, we'll simply
		* write to the first BAR2 SGE Queue Area within the BAR2 Page with
		* the BAR2 Queue ID and the hardware will infer the Absolute Queue ID
		* from the BAR2 Page and BAR2 Queue ID.
		*
		* One important censequence of this is that some BAR2 SGE registers
		* have a "Queue ID" field and we can write the BAR2 SGE Queue ID
		* there. But other registers synthesize the SGE Queue ID purely
		* from the writes to the registers -- the Write Combined Doorbell
		* Buffer is a good example. These BAR2 SGE Registers are only
		* available for those BAR2 SGE Register areas where the SGE Absolute
		* Queue ID can be inferred from simple writes.
		*/
		bar2_qoffset = bar2_page_offset;
		bar2_qinferred = (bar2_qid_offset < page_size);
		if (bar2_qinferred) {
		bar2_qoffset += bar2_qid_offset;
		bar2_qid = 0;
		}

		*pbar2_qoffset = bar2_qoffset;
		*pbar2_qid = bar2_qid;
		return 0;
		}

		/**
		* t4_init_sge_params - initialize adap->params.sge
		* @adapter: the adapter
		*
		* Initialize various fields of the adapter's SGE Parameters structure.
		*/
		int t4_init_sge_params(struct adapter *adapter)
		{
		struct sge_params *sge_params = &adapter->params.sge;
		u32 hps, qpp;
		unsigned int s_hps, s_qpp;

		/* Extract the SGE Page Size for our PF.
		*/
		hps = t4_read_reg(adapter, SGE_HOST_PAGE_SIZE);
		s_hps = (HOSTPAGESIZEPF0_S +
		(HOSTPAGESIZEPF1_S - HOSTPAGESIZEPF0_S) * adapter->fn);
		sge_params->hps = ((hps >> s_hps) & HOSTPAGESIZEPF0_M);

		/* Extract the SGE Egress and Ingess Queues Per Page for our PF.
		*/
		s_qpp = (QUEUESPERPAGEPF0_S +
		(QUEUESPERPAGEPF1_S - QUEUESPERPAGEPF0_S) * adapter->fn);
		qpp = t4_read_reg(adapter, SGE_EGRESS_QUEUES_PER_PAGE_PF);
		sge_params->eq_qpp = ((qpp >> s_qpp) & QUEUESPERPAGEPF0_MASK);
		qpp = t4_read_reg(adapter, SGE_INGRESS_QUEUES_PER_PAGE_PF);
		sge_params->iq_qpp = ((qpp >> s_qpp) & QUEUESPERPAGEPF0_MASK);

		return 0;
		}

		/**
		* t4_init_tp_params - initialize adap->params.tp
		* @adap: the adapter