Commit 0519f73a authored by Fan Fei's avatar Fan Fei Committed by Bjorn Helgaas
Browse files

PCI: xilinx: Rename xilinx_pcie_port to xilinx_pcie 

Rename struct xilinx_pcie_port to xilinx_pcie to match the convention of
<driver>_pcie. No functional change intended.

Link: https://lore.kernel.org/r/20211223011054.1227810-23-helgaas@kernel.org


Signed-off-by: default avatarFan Fei <ffclaire1224@gmail.com>
Signed-off-by: default avatarBjorn Helgaas <bhelgaas@google.com>
Acked-by: default avatarMichal Simek <michal.simek@xilinx.com>
parent 24d174a1

drivers/pci/controller/pcie-xilinx.c

+79 −79
Original line number Diff line number Diff line
@@ -91,18 +91,18 @@ 
#define XILINX_NUM_MSI_IRQS		128



/**

 * struct xilinx_pcie_port - PCIe port information

 * @reg_base: IO Mapped Register Base

 * struct xilinx_pcie - PCIe port information

 * @dev: Device pointer

 * @reg_base: IO Mapped Register Base

 * @msi_map: Bitmap of allocated MSIs

 * @map_lock: Mutex protecting the MSI allocation

 * @msi_domain: MSI IRQ domain pointer

 * @leg_domain: Legacy IRQ domain pointer

 * @resources: Bus Resources

 */

struct xilinx_pcie_port {

	void __iomem *reg_base;

struct xilinx_pcie {

	struct device *dev;

	void __iomem *reg_base;

	unsigned long msi_map[BITS_TO_LONGS(XILINX_NUM_MSI_IRQS)];

	struct mutex map_lock;

	struct irq_domain *msi_domain;
@@ -110,35 +110,35 @@ struct xilinx_pcie_port { 
	struct list_head resources;

};



static inline u32 pcie_read(struct xilinx_pcie_port *port, u32 reg)

static inline u32 pcie_read(struct xilinx_pcie *pcie, u32 reg)

{

	return readl(port->reg_base + reg);

	return readl(pcie->reg_base + reg);

}



static inline void pcie_write(struct xilinx_pcie_port *port, u32 val, u32 reg)

static inline void pcie_write(struct xilinx_pcie *pcie, u32 val, u32 reg)

{

	writel(val, port->reg_base + reg);

	writel(val, pcie->reg_base + reg);

}



static inline bool xilinx_pcie_link_up(struct xilinx_pcie_port *port)

static inline bool xilinx_pcie_link_up(struct xilinx_pcie *pcie)

{

	return (pcie_read(port, XILINX_PCIE_REG_PSCR) &

	return (pcie_read(pcie, XILINX_PCIE_REG_PSCR) &

		XILINX_PCIE_REG_PSCR_LNKUP) ? 1 : 0;

}



/**

 * xilinx_pcie_clear_err_interrupts - Clear Error Interrupts

 * @port: PCIe port information

 * @pcie: PCIe port information

 */

static void xilinx_pcie_clear_err_interrupts(struct xilinx_pcie_port *port)

static void xilinx_pcie_clear_err_interrupts(struct xilinx_pcie *pcie)

{

	struct device *dev = port->dev;

	unsigned long val = pcie_read(port, XILINX_PCIE_REG_RPEFR);

	struct device *dev = pcie->dev;

	unsigned long val = pcie_read(pcie, XILINX_PCIE_REG_RPEFR);



	if (val & XILINX_PCIE_RPEFR_ERR_VALID) {

		dev_dbg(dev, "Requester ID %lu\n",

			val & XILINX_PCIE_RPEFR_REQ_ID);

		pcie_write(port, XILINX_PCIE_RPEFR_ALL_MASK,

		pcie_write(pcie, XILINX_PCIE_RPEFR_ALL_MASK,

			   XILINX_PCIE_REG_RPEFR);

	}

}
@@ -152,11 +152,11 @@ static void xilinx_pcie_clear_err_interrupts(struct xilinx_pcie_port *port) 
 */

static bool xilinx_pcie_valid_device(struct pci_bus *bus, unsigned int devfn)

{

	struct xilinx_pcie_port *port = bus->sysdata;

	struct xilinx_pcie *pcie = bus->sysdata;



	/* Check if link is up when trying to access downstream ports */

	/* Check if link is up when trying to access downstream pcie ports */

	if (!pci_is_root_bus(bus)) {

		if (!xilinx_pcie_link_up(port))

		if (!xilinx_pcie_link_up(pcie))

			return false;

	} else if (devfn > 0) {

		/* Only one device down on each root port */
@@ -177,12 +177,12 @@ static bool xilinx_pcie_valid_device(struct pci_bus *bus, unsigned int devfn) 
static void __iomem *xilinx_pcie_map_bus(struct pci_bus *bus,

					 unsigned int devfn, int where)

{

	struct xilinx_pcie_port *port = bus->sysdata;

	struct xilinx_pcie *pcie = bus->sysdata;



	if (!xilinx_pcie_valid_device(bus, devfn))

		return NULL;



	return port->reg_base + PCIE_ECAM_OFFSET(bus->number, devfn, where);

	return pcie->reg_base + PCIE_ECAM_OFFSET(bus->number, devfn, where);

}



/* PCIe operations */
@@ -215,7 +215,7 @@ static int xilinx_msi_set_affinity(struct irq_data *d, const struct cpumask *mas 


static void xilinx_compose_msi_msg(struct irq_data *data, struct msi_msg *msg)

{

	struct xilinx_pcie_port *pcie = irq_data_get_irq_chip_data(data);

	struct xilinx_pcie *pcie = irq_data_get_irq_chip_data(data);

	phys_addr_t pa = ALIGN_DOWN(virt_to_phys(pcie), SZ_4K);



	msg->address_lo = lower_32_bits(pa);
@@ -232,14 +232,14 @@ static struct irq_chip xilinx_msi_bottom_chip = { 
static int xilinx_msi_domain_alloc(struct irq_domain *domain, unsigned int virq,

				  unsigned int nr_irqs, void *args)

{

	struct xilinx_pcie_port *port = domain->host_data;

	struct xilinx_pcie *pcie = domain->host_data;

	int hwirq, i;



	mutex_lock(&port->map_lock);

	mutex_lock(&pcie->map_lock);



	hwirq = bitmap_find_free_region(port->msi_map, XILINX_NUM_MSI_IRQS, order_base_2(nr_irqs));

	hwirq = bitmap_find_free_region(pcie->msi_map, XILINX_NUM_MSI_IRQS, order_base_2(nr_irqs));



	mutex_unlock(&port->map_lock);

	mutex_unlock(&pcie->map_lock);



	if (hwirq < 0)

		return -ENOSPC;
@@ -256,13 +256,13 @@ static void xilinx_msi_domain_free(struct irq_domain *domain, unsigned int virq, 
				  unsigned int nr_irqs)

{

	struct irq_data *d = irq_domain_get_irq_data(domain, virq);

	struct xilinx_pcie_port *port = domain->host_data;

	struct xilinx_pcie *pcie = domain->host_data;



	mutex_lock(&port->map_lock);

	mutex_lock(&pcie->map_lock);



	bitmap_release_region(port->msi_map, d->hwirq, order_base_2(nr_irqs));

	bitmap_release_region(pcie->msi_map, d->hwirq, order_base_2(nr_irqs));



	mutex_unlock(&port->map_lock);

	mutex_unlock(&pcie->map_lock);

}



static const struct irq_domain_ops xilinx_msi_domain_ops = {
@@ -275,7 +275,7 @@ static struct msi_domain_info xilinx_msi_info = { 
	.chip	= &xilinx_msi_top_chip,

};



static int xilinx_allocate_msi_domains(struct xilinx_pcie_port *pcie)

static int xilinx_allocate_msi_domains(struct xilinx_pcie *pcie)

{

	struct fwnode_handle *fwnode = dev_fwnode(pcie->dev);

	struct irq_domain *parent;
@@ -298,7 +298,7 @@ static int xilinx_allocate_msi_domains(struct xilinx_pcie_port *pcie) 
	return 0;

}



static void xilinx_free_msi_domains(struct xilinx_pcie_port *pcie)

static void xilinx_free_msi_domains(struct xilinx_pcie *pcie)

{

	struct irq_domain *parent = pcie->msi_domain->parent;
@@ -342,13 +342,13 @@ static const struct irq_domain_ops intx_domain_ops = { 
 */

static irqreturn_t xilinx_pcie_intr_handler(int irq, void *data)

{

	struct xilinx_pcie_port *port = (struct xilinx_pcie_port *)data;

	struct device *dev = port->dev;

	struct xilinx_pcie *pcie = (struct xilinx_pcie *)data;

	struct device *dev = pcie->dev;

	u32 val, mask, status;



	/* Read interrupt decode and mask registers */

	val = pcie_read(port, XILINX_PCIE_REG_IDR);

	mask = pcie_read(port, XILINX_PCIE_REG_IMR);

	val = pcie_read(pcie, XILINX_PCIE_REG_IDR);

	mask = pcie_read(pcie, XILINX_PCIE_REG_IMR);



	status = val & mask;

	if (!status)
@@ -371,23 +371,23 @@ static irqreturn_t xilinx_pcie_intr_handler(int irq, void *data) 


	if (status & XILINX_PCIE_INTR_CORRECTABLE) {

		dev_warn(dev, "Correctable error message\n");

		xilinx_pcie_clear_err_interrupts(port);

		xilinx_pcie_clear_err_interrupts(pcie);

	}



	if (status & XILINX_PCIE_INTR_NONFATAL) {

		dev_warn(dev, "Non fatal error message\n");

		xilinx_pcie_clear_err_interrupts(port);

		xilinx_pcie_clear_err_interrupts(pcie);

	}



	if (status & XILINX_PCIE_INTR_FATAL) {

		dev_warn(dev, "Fatal error message\n");

		xilinx_pcie_clear_err_interrupts(port);

		xilinx_pcie_clear_err_interrupts(pcie);

	}



	if (status & (XILINX_PCIE_INTR_INTX | XILINX_PCIE_INTR_MSI)) {

		struct irq_domain *domain;



		val = pcie_read(port, XILINX_PCIE_REG_RPIFR1);

		val = pcie_read(pcie, XILINX_PCIE_REG_RPIFR1);



		/* Check whether interrupt valid */

		if (!(val & XILINX_PCIE_RPIFR1_INTR_VALID)) {
@@ -397,17 +397,17 @@ static irqreturn_t xilinx_pcie_intr_handler(int irq, void *data) 


		/* Decode the IRQ number */

		if (val & XILINX_PCIE_RPIFR1_MSI_INTR) {

			val = pcie_read(port, XILINX_PCIE_REG_RPIFR2) &

			val = pcie_read(pcie, XILINX_PCIE_REG_RPIFR2) &

				XILINX_PCIE_RPIFR2_MSG_DATA;

			domain = port->msi_domain->parent;

			domain = pcie->msi_domain->parent;

		} else {

			val = (val & XILINX_PCIE_RPIFR1_INTR_MASK) >>

				XILINX_PCIE_RPIFR1_INTR_SHIFT;

			domain = port->leg_domain;

			domain = pcie->leg_domain;

		}



		/* Clear interrupt FIFO register 1 */

		pcie_write(port, XILINX_PCIE_RPIFR1_ALL_MASK,

		pcie_write(pcie, XILINX_PCIE_RPIFR1_ALL_MASK,

			   XILINX_PCIE_REG_RPIFR1);



		generic_handle_domain_irq(domain, val);
@@ -442,20 +442,20 @@ static irqreturn_t xilinx_pcie_intr_handler(int irq, void *data) 


error:

	/* Clear the Interrupt Decode register */

	pcie_write(port, status, XILINX_PCIE_REG_IDR);

	pcie_write(pcie, status, XILINX_PCIE_REG_IDR);



	return IRQ_HANDLED;

}



/**

 * xilinx_pcie_init_irq_domain - Initialize IRQ domain

 * @port: PCIe port information

 * @pcie: PCIe port information

 *

 * Return: '0' on success and error value on failure

 */

static int xilinx_pcie_init_irq_domain(struct xilinx_pcie_port *port)

static int xilinx_pcie_init_irq_domain(struct xilinx_pcie *pcie)

{

	struct device *dev = port->dev;

	struct device *dev = pcie->dev;

	struct device_node *pcie_intc_node;

	int ret;
@@ -466,25 +466,25 @@ static int xilinx_pcie_init_irq_domain(struct xilinx_pcie_port *port) 
		return -ENODEV;

	}



	port->leg_domain = irq_domain_add_linear(pcie_intc_node, PCI_NUM_INTX,

	pcie->leg_domain = irq_domain_add_linear(pcie_intc_node, PCI_NUM_INTX,

						 &intx_domain_ops,

						 port);

						 pcie);

	of_node_put(pcie_intc_node);

	if (!port->leg_domain) {

	if (!pcie->leg_domain) {

		dev_err(dev, "Failed to get a INTx IRQ domain\n");

		return -ENODEV;

	}



	/* Setup MSI */

	if (IS_ENABLED(CONFIG_PCI_MSI)) {

		phys_addr_t pa = ALIGN_DOWN(virt_to_phys(port), SZ_4K);

		phys_addr_t pa = ALIGN_DOWN(virt_to_phys(pcie), SZ_4K);



		ret = xilinx_allocate_msi_domains(port);

		ret = xilinx_allocate_msi_domains(pcie);

		if (ret)

			return ret;



		pcie_write(port, upper_32_bits(pa), XILINX_PCIE_REG_MSIBASE1);

		pcie_write(port, lower_32_bits(pa), XILINX_PCIE_REG_MSIBASE2);

		pcie_write(pcie, upper_32_bits(pa), XILINX_PCIE_REG_MSIBASE1);

		pcie_write(pcie, lower_32_bits(pa), XILINX_PCIE_REG_MSIBASE2);

	}



	return 0;
@@ -492,44 +492,44 @@ static int xilinx_pcie_init_irq_domain(struct xilinx_pcie_port *port) 


/**

 * xilinx_pcie_init_port - Initialize hardware

 * @port: PCIe port information

 * @pcie: PCIe port information

 */

static void xilinx_pcie_init_port(struct xilinx_pcie_port *port)

static void xilinx_pcie_init_port(struct xilinx_pcie *pcie)

{

	struct device *dev = port->dev;

	struct device *dev = pcie->dev;



	if (xilinx_pcie_link_up(port))

	if (xilinx_pcie_link_up(pcie))

		dev_info(dev, "PCIe Link is UP\n");

	else

		dev_info(dev, "PCIe Link is DOWN\n");



	/* Disable all interrupts */

	pcie_write(port, ~XILINX_PCIE_IDR_ALL_MASK,

	pcie_write(pcie, ~XILINX_PCIE_IDR_ALL_MASK,

		   XILINX_PCIE_REG_IMR);



	/* Clear pending interrupts */

	pcie_write(port, pcie_read(port, XILINX_PCIE_REG_IDR) &

	pcie_write(pcie, pcie_read(pcie, XILINX_PCIE_REG_IDR) &

			 XILINX_PCIE_IMR_ALL_MASK,

		   XILINX_PCIE_REG_IDR);



	/* Enable all interrupts we handle */

	pcie_write(port, XILINX_PCIE_IMR_ENABLE_MASK, XILINX_PCIE_REG_IMR);

	pcie_write(pcie, XILINX_PCIE_IMR_ENABLE_MASK, XILINX_PCIE_REG_IMR);



	/* Enable the Bridge enable bit */

	pcie_write(port, pcie_read(port, XILINX_PCIE_REG_RPSC) |

	pcie_write(pcie, pcie_read(pcie, XILINX_PCIE_REG_RPSC) |

			 XILINX_PCIE_REG_RPSC_BEN,

		   XILINX_PCIE_REG_RPSC);

}



/**

 * xilinx_pcie_parse_dt - Parse Device tree

 * @port: PCIe port information

 * @pcie: PCIe port information

 *

 * Return: '0' on success and error value on failure

 */

static int xilinx_pcie_parse_dt(struct xilinx_pcie_port *port)

static int xilinx_pcie_parse_dt(struct xilinx_pcie *pcie)

{

	struct device *dev = port->dev;

	struct device *dev = pcie->dev;

	struct device_node *node = dev->of_node;

	struct resource regs;

	unsigned int irq;
@@ -541,14 +541,14 @@ static int xilinx_pcie_parse_dt(struct xilinx_pcie_port *port) 
		return err;

	}



	port->reg_base = devm_pci_remap_cfg_resource(dev, &regs);

	if (IS_ERR(port->reg_base))

		return PTR_ERR(port->reg_base);

	pcie->reg_base = devm_pci_remap_cfg_resource(dev, &regs);

	if (IS_ERR(pcie->reg_base))

		return PTR_ERR(pcie->reg_base);



	irq = irq_of_parse_and_map(node, 0);

	err = devm_request_irq(dev, irq, xilinx_pcie_intr_handler,

			       IRQF_SHARED | IRQF_NO_THREAD,

			       "xilinx-pcie", port);

			       "xilinx-pcie", pcie);

	if (err) {

		dev_err(dev, "unable to request irq %d\n", irq);

		return err;
@@ -566,41 +566,41 @@ static int xilinx_pcie_parse_dt(struct xilinx_pcie_port *port) 
static int xilinx_pcie_probe(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	struct xilinx_pcie_port *port;

	struct xilinx_pcie *pcie;

	struct pci_host_bridge *bridge;

	int err;



	if (!dev->of_node)

		return -ENODEV;



	bridge = devm_pci_alloc_host_bridge(dev, sizeof(*port));

	bridge = devm_pci_alloc_host_bridge(dev, sizeof(*pcie));

	if (!bridge)

		return -ENODEV;



	port = pci_host_bridge_priv(bridge);

	mutex_init(&port->map_lock);

	port->dev = dev;

	pcie = pci_host_bridge_priv(bridge);

	mutex_init(&pcie->map_lock);

	pcie->dev = dev;



	err = xilinx_pcie_parse_dt(port);

	err = xilinx_pcie_parse_dt(pcie);

	if (err) {

		dev_err(dev, "Parsing DT failed\n");

		return err;

	}



	xilinx_pcie_init_port(port);

	xilinx_pcie_init_port(pcie);



	err = xilinx_pcie_init_irq_domain(port);

	err = xilinx_pcie_init_irq_domain(pcie);

	if (err) {

		dev_err(dev, "Failed creating IRQ Domain\n");

		return err;

	}



	bridge->sysdata = port;

	bridge->sysdata = pcie;

	bridge->ops = &xilinx_pcie_ops;



	err = pci_host_probe(bridge);

	if (err)

		xilinx_free_msi_domains(port);

		xilinx_free_msi_domains(pcie);



	return err;

}