NTB: Rename Variables for NTB-RP (49793889) · Commits · e / devices / android_kernel_xiaomi_nabu

drivers/ntb/ntb_hw.c

+41 −42

Original line number	Original line	Diff line number	Diff line
	@@ -167,9 +167,9 @@ int ntb_register_db_callback(struct ntb_device *ndev, unsigned int idx,
	ndev->db_cb[idx].data = data;		ndev->db_cb[idx].data = data;

	/* unmask interrupt */		/* unmask interrupt */
	mask = readw(ndev->reg_ofs.pdb_mask);		mask = readw(ndev->reg_ofs.ldb_mask);
	clear_bit(idx * ndev->bits_per_vector, &mask);		clear_bit(idx * ndev->bits_per_vector, &mask);
	writew(mask, ndev->reg_ofs.pdb_mask);		writew(mask, ndev->reg_ofs.ldb_mask);

	return 0;		return 0;
	}		}
	@@ -189,9 +189,9 @@ void ntb_unregister_db_callback(struct ntb_device *ndev, unsigned int idx)
	if (idx >= ndev->max_cbs \|\| !ndev->db_cb[idx].callback)		if (idx >= ndev->max_cbs \|\| !ndev->db_cb[idx].callback)
	return;		return;

	mask = readw(ndev->reg_ofs.pdb_mask);		mask = readw(ndev->reg_ofs.ldb_mask);
	set_bit(idx * ndev->bits_per_vector, &mask);		set_bit(idx * ndev->bits_per_vector, &mask);
	writew(mask, ndev->reg_ofs.pdb_mask);		writew(mask, ndev->reg_ofs.ldb_mask);

	ndev->db_cb[idx].callback = NULL;		ndev->db_cb[idx].callback = NULL;
	}		}
	@@ -423,16 +423,16 @@ void ntb_set_mw_addr(struct ntb_device *ndev, unsigned int mw, u64 addr)

	switch (MW_TO_BAR(mw)) {		switch (MW_TO_BAR(mw)) {
	case NTB_BAR_23:		case NTB_BAR_23:
	writeq(addr, ndev->reg_ofs.sbar2_xlat);		writeq(addr, ndev->reg_ofs.bar2_xlat);
	break;		break;
	case NTB_BAR_45:		case NTB_BAR_45:
	writeq(addr, ndev->reg_ofs.sbar4_xlat);		writeq(addr, ndev->reg_ofs.bar4_xlat);
	break;		break;
	}		}
	}		}

	/**		/**
	* ntb_ring_sdb() - Set the doorbell on the secondary/external side		* ntb_ring_doorbell() - Set the doorbell on the secondary/external side
	* @ndev: pointer to ntb_device instance		* @ndev: pointer to ntb_device instance
	* @db: doorbell to ring		* @db: doorbell to ring
	*		*
	@@ -441,15 +441,15 @@ void ntb_set_mw_addr(struct ntb_device *ndev, unsigned int mw, u64 addr)
	*		*
	* RETURNS: An appropriate -ERRNO error value on error, or zero for success.		* RETURNS: An appropriate -ERRNO error value on error, or zero for success.
	*/		*/
	void ntb_ring_sdb(struct ntb_device *ndev, unsigned int db)		void ntb_ring_doorbell(struct ntb_device *ndev, unsigned int db)
	{		{
	dev_dbg(&ndev->pdev->dev, "%s: ringing doorbell %d\n", __func__, db);		dev_dbg(&ndev->pdev->dev, "%s: ringing doorbell %d\n", __func__, db);

	if (ndev->hw_type == BWD_HW)		if (ndev->hw_type == BWD_HW)
	writeq((u64) 1 << db, ndev->reg_ofs.sdb);		writeq((u64) 1 << db, ndev->reg_ofs.rdb);
	else		else
	writew(((1 << ndev->bits_per_vector) - 1) <<		writew(((1 << ndev->bits_per_vector) - 1) <<
	(db * ndev->bits_per_vector), ndev->reg_ofs.sdb);		(db * ndev->bits_per_vector), ndev->reg_ofs.rdb);
	}		}

	static void bwd_recover_link(struct ntb_device *ndev)		static void bwd_recover_link(struct ntb_device *ndev)
	@@ -665,10 +665,10 @@ static int ntb_xeon_setup(struct ntb_device *ndev)
	else		else
	ndev->dev_type = NTB_DEV_DSD;		ndev->dev_type = NTB_DEV_DSD;

	ndev->reg_ofs.pdb = ndev->reg_base + SNB_PDOORBELL_OFFSET;		ndev->reg_ofs.ldb = ndev->reg_base + SNB_PDOORBELL_OFFSET;
	ndev->reg_ofs.pdb_mask = ndev->reg_base + SNB_PDBMSK_OFFSET;		ndev->reg_ofs.ldb_mask = ndev->reg_base + SNB_PDBMSK_OFFSET;
	ndev->reg_ofs.sbar2_xlat = ndev->reg_base + SNB_SBAR2XLAT_OFFSET;		ndev->reg_ofs.bar2_xlat = ndev->reg_base + SNB_SBAR2XLAT_OFFSET;
	ndev->reg_ofs.sbar4_xlat = ndev->reg_base + SNB_SBAR4XLAT_OFFSET;		ndev->reg_ofs.bar4_xlat = ndev->reg_base + SNB_SBAR4XLAT_OFFSET;
	ndev->reg_ofs.lnk_cntl = ndev->reg_base + SNB_NTBCNTL_OFFSET;		ndev->reg_ofs.lnk_cntl = ndev->reg_base + SNB_NTBCNTL_OFFSET;
	ndev->reg_ofs.lnk_stat = ndev->reg_base + SNB_LINK_STATUS_OFFSET;		ndev->reg_ofs.lnk_stat = ndev->reg_base + SNB_LINK_STATUS_OFFSET;
	ndev->reg_ofs.spad_read = ndev->reg_base + SNB_SPAD_OFFSET;		ndev->reg_ofs.spad_read = ndev->reg_base + SNB_SPAD_OFFSET;
	@@ -687,7 +687,7 @@ static int ntb_xeon_setup(struct ntb_device *ndev)
	ndev->limits.max_mw = SNB_ERRATA_MAX_MW;		ndev->limits.max_mw = SNB_ERRATA_MAX_MW;
	ndev->reg_ofs.spad_write = ndev->mw[1].vbase +		ndev->reg_ofs.spad_write = ndev->mw[1].vbase +
	SNB_SPAD_OFFSET;		SNB_SPAD_OFFSET;
	ndev->reg_ofs.sdb = ndev->mw[1].vbase +		ndev->reg_ofs.rdb = ndev->mw[1].vbase +
	SNB_PDOORBELL_OFFSET;		SNB_PDOORBELL_OFFSET;

	/* Set the Limit register to 4k, the minimum size, to		/* Set the Limit register to 4k, the minimum size, to
	@@ -699,7 +699,7 @@ static int ntb_xeon_setup(struct ntb_device *ndev)
	ndev->limits.max_mw = SNB_MAX_MW;		ndev->limits.max_mw = SNB_MAX_MW;
	ndev->reg_ofs.spad_write = ndev->reg_base +		ndev->reg_ofs.spad_write = ndev->reg_base +
	SNB_B2B_SPAD_OFFSET;		SNB_B2B_SPAD_OFFSET;
	ndev->reg_ofs.sdb = ndev->reg_base +		ndev->reg_ofs.rdb = ndev->reg_base +
	SNB_B2B_DOORBELL_OFFSET;		SNB_B2B_DOORBELL_OFFSET;

	/* Disable the Limit register, just incase it is set to		/* Disable the Limit register, just incase it is set to
	@@ -801,21 +801,21 @@ static int ntb_bwd_setup(struct ntb_device *ndev)
	if (rc)		if (rc)
	return rc;		return rc;

	ndev->reg_ofs.pdb = ndev->reg_base + BWD_PDOORBELL_OFFSET;		ndev->reg_ofs.ldb = ndev->reg_base + BWD_PDOORBELL_OFFSET;
	ndev->reg_ofs.pdb_mask = ndev->reg_base + BWD_PDBMSK_OFFSET;		ndev->reg_ofs.ldb_mask = ndev->reg_base + BWD_PDBMSK_OFFSET;
	ndev->reg_ofs.sbar2_xlat = ndev->reg_base + BWD_SBAR2XLAT_OFFSET;		ndev->reg_ofs.bar2_xlat = ndev->reg_base + BWD_SBAR2XLAT_OFFSET;
	ndev->reg_ofs.sbar4_xlat = ndev->reg_base + BWD_SBAR4XLAT_OFFSET;		ndev->reg_ofs.bar4_xlat = ndev->reg_base + BWD_SBAR4XLAT_OFFSET;
	ndev->reg_ofs.lnk_cntl = ndev->reg_base + BWD_NTBCNTL_OFFSET;		ndev->reg_ofs.lnk_cntl = ndev->reg_base + BWD_NTBCNTL_OFFSET;
	ndev->reg_ofs.lnk_stat = ndev->reg_base + BWD_LINK_STATUS_OFFSET;		ndev->reg_ofs.lnk_stat = ndev->reg_base + BWD_LINK_STATUS_OFFSET;
	ndev->reg_ofs.spad_read = ndev->reg_base + BWD_SPAD_OFFSET;		ndev->reg_ofs.spad_read = ndev->reg_base + BWD_SPAD_OFFSET;
	ndev->reg_ofs.spci_cmd = ndev->reg_base + BWD_PCICMD_OFFSET;		ndev->reg_ofs.spci_cmd = ndev->reg_base + BWD_PCICMD_OFFSET;

	if (ndev->conn_type == NTB_CONN_B2B) {		if (ndev->conn_type == NTB_CONN_B2B) {
	ndev->reg_ofs.sdb = ndev->reg_base + BWD_B2B_DOORBELL_OFFSET;		ndev->reg_ofs.rdb = ndev->reg_base + BWD_B2B_DOORBELL_OFFSET;
	ndev->reg_ofs.spad_write = ndev->reg_base + BWD_B2B_SPAD_OFFSET;		ndev->reg_ofs.spad_write = ndev->reg_base + BWD_B2B_SPAD_OFFSET;
	ndev->limits.max_spads = BWD_MAX_SPADS;		ndev->limits.max_spads = BWD_MAX_SPADS;
	} else {		} else {
	ndev->reg_ofs.sdb = ndev->reg_base + BWD_PDOORBELL_OFFSET;		ndev->reg_ofs.rdb = ndev->reg_base + BWD_PDOORBELL_OFFSET;
	ndev->reg_ofs.spad_write = ndev->reg_base + BWD_SPAD_OFFSET;		ndev->reg_ofs.spad_write = ndev->reg_base + BWD_SPAD_OFFSET;
	ndev->limits.max_spads = BWD_MAX_COMPAT_SPADS;		ndev->limits.max_spads = BWD_MAX_COMPAT_SPADS;
	}		}
	@@ -895,7 +895,7 @@ static irqreturn_t bwd_callback_msix_irq(int irq, void *data)
	*/		*/
	ndev->last_ts = jiffies;		ndev->last_ts = jiffies;

	writeq((u64) 1 << db_cb->db_num, ndev->reg_ofs.pdb);		writeq((u64) 1 << db_cb->db_num, ndev->reg_ofs.ldb);

	return IRQ_HANDLED;		return IRQ_HANDLED;
	}		}
	@@ -917,7 +917,7 @@ static irqreturn_t xeon_callback_msix_irq(int irq, void *data)
	* interrupts.		* interrupts.
	*/		*/
	writew(((1 << ndev->bits_per_vector) - 1) <<		writew(((1 << ndev->bits_per_vector) - 1) <<
	(db_cb->db_num * ndev->bits_per_vector), ndev->reg_ofs.pdb);		(db_cb->db_num * ndev->bits_per_vector), ndev->reg_ofs.ldb);

	return IRQ_HANDLED;		return IRQ_HANDLED;
	}		}
	@@ -935,7 +935,7 @@ static irqreturn_t xeon_event_msix_irq(int irq, void *dev)
	dev_err(&ndev->pdev->dev, "Error determining link status\n");		dev_err(&ndev->pdev->dev, "Error determining link status\n");

	/* bit 15 is always the link bit */		/* bit 15 is always the link bit */
	writew(1 << ndev->limits.max_db_bits, ndev->reg_ofs.pdb);		writew(1 << ndev->limits.max_db_bits, ndev->reg_ofs.ldb);

	return IRQ_HANDLED;		return IRQ_HANDLED;
	}		}
	@@ -946,29 +946,28 @@ static irqreturn_t ntb_interrupt(int irq, void *dev)
	unsigned int i = 0;		unsigned int i = 0;

	if (ndev->hw_type == BWD_HW) {		if (ndev->hw_type == BWD_HW) {
	u64 pdb = readq(ndev->reg_ofs.pdb);		u64 ldb = readq(ndev->reg_ofs.ldb);

	dev_dbg(&ndev->pdev->dev, "irq %d - pdb = %Lx\n", irq, pdb);		dev_dbg(&ndev->pdev->dev, "irq %d - ldb = %Lx\n", irq, ldb);

	while (pdb) {		while (ldb) {
	i = __ffs(pdb);		i = __ffs(ldb);
	pdb &= pdb - 1;		ldb &= ldb - 1;
	bwd_callback_msix_irq(irq, &ndev->db_cb[i]);		bwd_callback_msix_irq(irq, &ndev->db_cb[i]);
	}		}
	} else {		} else {
	u16 pdb = readw(ndev->reg_ofs.pdb);		u16 ldb = readw(ndev->reg_ofs.ldb);

	dev_dbg(&ndev->pdev->dev, "irq %d - pdb = %x sdb %x\n", irq,		dev_dbg(&ndev->pdev->dev, "irq %d - ldb = %x\n", irq, ldb);
	pdb, readw(ndev->reg_ofs.sdb));

	if (pdb & SNB_DB_HW_LINK) {		if (ldb & SNB_DB_HW_LINK) {
	xeon_event_msix_irq(irq, dev);		xeon_event_msix_irq(irq, dev);
	pdb &= ~SNB_DB_HW_LINK;		ldb &= ~SNB_DB_HW_LINK;
	}		}

	while (pdb) {		while (ldb) {
	i = __ffs(pdb);		i = __ffs(ldb);
	pdb &= pdb - 1;		ldb &= ldb - 1;
	xeon_callback_msix_irq(irq, &ndev->db_cb[i]);		xeon_callback_msix_irq(irq, &ndev->db_cb[i]);
	}		}
	}		}
	@@ -1126,10 +1125,10 @@ static int ntb_setup_interrupts(struct ntb_device *ndev)
	* Interrupt. The rest will be unmasked as callbacks are registered.		* Interrupt. The rest will be unmasked as callbacks are registered.
	*/		*/
	if (ndev->hw_type == BWD_HW)		if (ndev->hw_type == BWD_HW)
	writeq(~0, ndev->reg_ofs.pdb_mask);		writeq(~0, ndev->reg_ofs.ldb_mask);
	else		else
	writew(~(1 << ndev->limits.max_db_bits),		writew(~(1 << ndev->limits.max_db_bits),
	ndev->reg_ofs.pdb_mask);		ndev->reg_ofs.ldb_mask);

	rc = ntb_setup_msix(ndev);		rc = ntb_setup_msix(ndev);
	if (!rc)		if (!rc)
	@@ -1158,9 +1157,9 @@ static void ntb_free_interrupts(struct ntb_device *ndev)

	/* mask interrupts */		/* mask interrupts */
	if (ndev->hw_type == BWD_HW)		if (ndev->hw_type == BWD_HW)
	writeq(~0, ndev->reg_ofs.pdb_mask);		writeq(~0, ndev->reg_ofs.ldb_mask);
	else		else
	writew(~0, ndev->reg_ofs.pdb_mask);		writew(~0, ndev->reg_ofs.ldb_mask);

	if (ndev->num_msix) {		if (ndev->num_msix) {
	struct msix_entry *msix;		struct msix_entry *msix;

drivers/ntb/ntb_hw.h

+6 −6

Original line number	Original line	Diff line number	Diff line
	@@ -124,11 +124,11 @@ struct ntb_device {
	unsigned char msix_cnt;		unsigned char msix_cnt;
	} limits;		} limits;
	struct {		struct {
	void __iomem *pdb;		void __iomem *ldb;
	void __iomem *pdb_mask;		void __iomem *ldb_mask;
	void __iomem *sdb;		void __iomem *rdb;
	void __iomem *sbar2_xlat;		void __iomem *bar2_xlat;
	void __iomem *sbar4_xlat;		void __iomem *bar4_xlat;
	void __iomem *spad_write;		void __iomem *spad_write;
	void __iomem *spad_read;		void __iomem *spad_read;
	void __iomem *lnk_cntl;		void __iomem *lnk_cntl;
	@@ -243,7 +243,7 @@ int ntb_read_remote_spad(struct ntb_device ndev, unsigned int idx, u32 val);
	resource_size_t ntb_get_mw_base(struct ntb_device *ndev, unsigned int mw);		resource_size_t ntb_get_mw_base(struct ntb_device *ndev, unsigned int mw);
	void __iomem ntb_get_mw_vbase(struct ntb_device ndev, unsigned int mw);		void __iomem ntb_get_mw_vbase(struct ntb_device ndev, unsigned int mw);
	u64 ntb_get_mw_size(struct ntb_device *ndev, unsigned int mw);		u64 ntb_get_mw_size(struct ntb_device *ndev, unsigned int mw);
	void ntb_ring_sdb(struct ntb_device *ndev, unsigned int idx);		void ntb_ring_doorbell(struct ntb_device *ndev, unsigned int idx);
	void ntb_find_transport(struct pci_dev pdev);		void ntb_find_transport(struct pci_dev pdev);

	int ntb_transport_init(struct pci_dev *pdev);		int ntb_transport_init(struct pci_dev *pdev);

drivers/ntb/ntb_transport.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -1216,7 +1216,7 @@ static void ntb_tx_copy_callback(void *data)
	wmb();		wmb();
	iowrite32(entry->flags \| DESC_DONE_FLAG, &hdr->flags);		iowrite32(entry->flags \| DESC_DONE_FLAG, &hdr->flags);

	ntb_ring_sdb(qp->ndev, qp->qp_num);		ntb_ring_doorbell(qp->ndev, qp->qp_num);

	/* The entry length can only be zero if the packet is intended to be a		/* The entry length can only be zero if the packet is intended to be a
	* "link down" or similar. Since no payload is being sent in these		* "link down" or similar. Since no payload is being sent in these