Merge branch 'pci/msi' into next (c6a7a77c) · Commits · 戴 / test

drivers/of/of_pci.c

+0 −45

Original line number	Diff line number	Diff line
		@@ -285,51 +285,6 @@ parse_failed:
		EXPORT_SYMBOL_GPL(of_pci_get_host_bridge_resources);
		#endif /* CONFIG_OF_ADDRESS */

		#ifdef CONFIG_PCI_MSI

		static LIST_HEAD(of_pci_msi_chip_list);
		static DEFINE_MUTEX(of_pci_msi_chip_mutex);

		int of_pci_msi_chip_add(struct msi_controller *chip)
		{
		if (!of_property_read_bool(chip->of_node, "msi-controller"))
		return -EINVAL;

		mutex_lock(&of_pci_msi_chip_mutex);
		list_add(&chip->list, &of_pci_msi_chip_list);
		mutex_unlock(&of_pci_msi_chip_mutex);

		return 0;
		}
		EXPORT_SYMBOL_GPL(of_pci_msi_chip_add);

		void of_pci_msi_chip_remove(struct msi_controller *chip)
		{
		mutex_lock(&of_pci_msi_chip_mutex);
		list_del(&chip->list);
		mutex_unlock(&of_pci_msi_chip_mutex);
		}
		EXPORT_SYMBOL_GPL(of_pci_msi_chip_remove);

		struct msi_controller of_pci_find_msi_chip_by_node(struct device_node of_node)
		{
		struct msi_controller *c;

		mutex_lock(&of_pci_msi_chip_mutex);
		list_for_each_entry(c, &of_pci_msi_chip_list, list) {
		if (c->of_node == of_node) {
		mutex_unlock(&of_pci_msi_chip_mutex);
		return c;
		}
		}
		mutex_unlock(&of_pci_msi_chip_mutex);

		return NULL;
		}
		EXPORT_SYMBOL_GPL(of_pci_find_msi_chip_by_node);

		#endif /* CONFIG_PCI_MSI */

		/**
		* of_pci_map_rid - Translate a requester ID through a downstream mapping.
		* @np: root complex device node.

drivers/pci/host/pci-aardvark.c

+67 −106

Original line number	Diff line number	Diff line
		@@ -200,10 +200,12 @@ struct advk_pcie {
		struct list_head resources;
		struct irq_domain *irq_domain;
		struct irq_chip irq_chip;
		struct msi_controller msi;
		struct irq_domain *msi_domain;
		struct irq_domain *msi_inner_domain;
		struct irq_chip msi_bottom_irq_chip;
		struct irq_chip msi_irq_chip;
		DECLARE_BITMAP(msi_irq_in_use, MSI_IRQ_NUM);
		struct msi_domain_info msi_domain_info;
		DECLARE_BITMAP(msi_used, MSI_IRQ_NUM);
		struct mutex msi_used_lock;
		u16 msi_msg;
		int root_bus_nr;
		@@ -545,94 +547,64 @@ static struct pci_ops advk_pcie_ops = {
		.write = advk_pcie_wr_conf,
		};

		static int advk_pcie_alloc_msi(struct advk_pcie *pcie)
		static void advk_msi_irq_compose_msi_msg(struct irq_data *data,
		struct msi_msg *msg)
		{
		int hwirq;
		struct advk_pcie *pcie = irq_data_get_irq_chip_data(data);
		phys_addr_t msi_msg = virt_to_phys(&pcie->msi_msg);

		mutex_lock(&pcie->msi_used_lock);
		hwirq = find_first_zero_bit(pcie->msi_irq_in_use, MSI_IRQ_NUM);
		if (hwirq >= MSI_IRQ_NUM)
		hwirq = -ENOSPC;
		else
		set_bit(hwirq, pcie->msi_irq_in_use);
		mutex_unlock(&pcie->msi_used_lock);
		msg->address_lo = lower_32_bits(msi_msg);
		msg->address_hi = upper_32_bits(msi_msg);
		msg->data = data->irq;
		}

		return hwirq;
		static int advk_msi_set_affinity(struct irq_data *irq_data,
		const struct cpumask *mask, bool force)
		{
		return -EINVAL;
		}

		static void advk_pcie_free_msi(struct advk_pcie *pcie, int hwirq)
		static int advk_msi_irq_domain_alloc(struct irq_domain *domain,
		unsigned int virq,
		unsigned int nr_irqs, void *args)
		{
		struct device *dev = &pcie->pdev->dev;
		struct advk_pcie *pcie = domain->host_data;
		int hwirq, i;

		mutex_lock(&pcie->msi_used_lock);
		if (!test_bit(hwirq, pcie->msi_irq_in_use))
		dev_err(dev, "trying to free unused MSI#%d\n", hwirq);
		else
		clear_bit(hwirq, pcie->msi_irq_in_use);
		hwirq = bitmap_find_next_zero_area(pcie->msi_used, MSI_IRQ_NUM,
		0, nr_irqs, 0);
		if (hwirq >= MSI_IRQ_NUM) {
		mutex_unlock(&pcie->msi_used_lock);
		return -ENOSPC;
		}

		static int advk_pcie_setup_msi_irq(struct msi_controller *chip,
		struct pci_dev *pdev,
		struct msi_desc *desc)
		{
		struct advk_pcie *pcie = pdev->bus->sysdata;
		struct msi_msg msg;
		int virq, hwirq;
		phys_addr_t msi_msg_phys;
		bitmap_set(pcie->msi_used, hwirq, nr_irqs);
		mutex_unlock(&pcie->msi_used_lock);

		/* We support MSI, but not MSI-X */
		if (desc->msi_attrib.is_msix)
		return -EINVAL;
		for (i = 0; i < nr_irqs; i++)
		irq_domain_set_info(domain, virq + i, hwirq + i,
		&pcie->msi_bottom_irq_chip,
		domain->host_data, handle_simple_irq,
		NULL, NULL);

		hwirq = advk_pcie_alloc_msi(pcie);
		if (hwirq < 0)
		return hwirq;

		virq = irq_create_mapping(pcie->msi_domain, hwirq);
		if (!virq) {
		advk_pcie_free_msi(pcie, hwirq);
		return -EINVAL;
		}

		irq_set_msi_desc(virq, desc);

		msi_msg_phys = virt_to_phys(&pcie->msi_msg);

		msg.address_lo = lower_32_bits(msi_msg_phys);
		msg.address_hi = upper_32_bits(msi_msg_phys);
		msg.data = virq;

		pci_write_msi_msg(virq, &msg);

		return 0;
		}

		static void advk_pcie_teardown_msi_irq(struct msi_controller *chip,
		unsigned int irq)
		{
		struct irq_data *d = irq_get_irq_data(irq);
		struct msi_desc *msi = irq_data_get_msi_desc(d);
		struct advk_pcie *pcie = msi_desc_to_pci_sysdata(msi);
		unsigned long hwirq = d->hwirq;

		irq_dispose_mapping(irq);
		advk_pcie_free_msi(pcie, hwirq);
		}

		static int advk_pcie_msi_map(struct irq_domain *domain,
		unsigned int virq, irq_hw_number_t hw)
		static void advk_msi_irq_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 advk_pcie *pcie = domain->host_data;

		irq_set_chip_and_handler(virq, &pcie->msi_irq_chip,
		handle_simple_irq);

		return 0;
		mutex_lock(&pcie->msi_used_lock);
		bitmap_clear(pcie->msi_used, d->hwirq, nr_irqs);
		mutex_unlock(&pcie->msi_used_lock);
		}

		static const struct irq_domain_ops advk_pcie_msi_irq_ops = {
		.map = advk_pcie_msi_map,
		static const struct irq_domain_ops advk_msi_domain_ops = {
		.alloc = advk_msi_irq_domain_alloc,
		.free = advk_msi_irq_domain_free,
		};

		static void advk_pcie_irq_mask(struct irq_data *d)
		@@ -680,30 +652,25 @@ static int advk_pcie_init_msi_irq_domain(struct advk_pcie *pcie)
		{
		struct device *dev = &pcie->pdev->dev;
		struct device_node *node = dev->of_node;
		struct irq_chip *msi_irq_chip;
		struct msi_controller *msi;
		struct irq_chip bottom_ic, msi_ic;
		struct msi_domain_info *msi_di;
		phys_addr_t msi_msg_phys;
		int ret;

		msi_irq_chip = &pcie->msi_irq_chip;

		msi_irq_chip->name = devm_kasprintf(dev, GFP_KERNEL, "%s-msi",
		dev_name(dev));
		if (!msi_irq_chip->name)
		return -ENOMEM;
		mutex_init(&pcie->msi_used_lock);

		msi_irq_chip->irq_enable = pci_msi_unmask_irq;
		msi_irq_chip->irq_disable = pci_msi_mask_irq;
		msi_irq_chip->irq_mask = pci_msi_mask_irq;
		msi_irq_chip->irq_unmask = pci_msi_unmask_irq;
		bottom_ic = &pcie->msi_bottom_irq_chip;

		msi = &pcie->msi;
		bottom_ic->name = "MSI";
		bottom_ic->irq_compose_msi_msg = advk_msi_irq_compose_msi_msg;
		bottom_ic->irq_set_affinity = advk_msi_set_affinity;

		msi->setup_irq = advk_pcie_setup_msi_irq;
		msi->teardown_irq = advk_pcie_teardown_msi_irq;
		msi->of_node = node;
		msi_ic = &pcie->msi_irq_chip;
		msi_ic->name = "advk-MSI";

		mutex_init(&pcie->msi_used_lock);
		msi_di = &pcie->msi_domain_info;
		msi_di->flags = MSI_FLAG_USE_DEF_DOM_OPS \| MSI_FLAG_USE_DEF_CHIP_OPS \|
		MSI_FLAG_MULTI_PCI_MSI;
		msi_di->chip = msi_ic;

		msi_msg_phys = virt_to_phys(&pcie->msi_msg);

		@@ -712,16 +679,18 @@ static int advk_pcie_init_msi_irq_domain(struct advk_pcie *pcie)
		advk_writel(pcie, upper_32_bits(msi_msg_phys),
		PCIE_MSI_ADDR_HIGH_REG);

		pcie->msi_domain =
		pcie->msi_inner_domain =
		irq_domain_add_linear(NULL, MSI_IRQ_NUM,
		&advk_pcie_msi_irq_ops, pcie);
		if (!pcie->msi_domain)
		&advk_msi_domain_ops, pcie);
		if (!pcie->msi_inner_domain)
		return -ENOMEM;

		ret = of_pci_msi_chip_add(msi);
		if (ret < 0) {
		irq_domain_remove(pcie->msi_domain);
		return ret;
		pcie->msi_domain =
		pci_msi_create_irq_domain(of_node_to_fwnode(node),
		msi_di, pcie->msi_inner_domain);
		if (!pcie->msi_domain) {
		irq_domain_remove(pcie->msi_inner_domain);
		return -ENOMEM;
		}

		return 0;
		@@ -729,8 +698,8 @@ static int advk_pcie_init_msi_irq_domain(struct advk_pcie *pcie)

		static void advk_pcie_remove_msi_irq_domain(struct advk_pcie *pcie)
		{
		of_pci_msi_chip_remove(&pcie->msi);
		irq_domain_remove(pcie->msi_domain);
		irq_domain_remove(pcie->msi_inner_domain);
		}

		static int advk_pcie_init_irq_domain(struct advk_pcie *pcie)
		@@ -917,8 +886,6 @@ static int advk_pcie_probe(struct platform_device *pdev)
		struct advk_pcie *pcie;
		struct resource *res;
		struct pci_bus bus, child;
		struct msi_controller *msi;
		struct device_node *msi_node;
		int ret, irq;

		pcie = devm_kzalloc(dev, sizeof(struct advk_pcie), GFP_KERNEL);
		@@ -962,14 +929,8 @@ static int advk_pcie_probe(struct platform_device *pdev)
		return ret;
		}

		msi_node = of_parse_phandle(dev->of_node, "msi-parent", 0);
		if (msi_node)
		msi = of_pci_find_msi_chip_by_node(msi_node);
		else
		msi = NULL;

		bus = pci_scan_root_bus_msi(dev, 0, &advk_pcie_ops,
		pcie, &pcie->resources, &pcie->msi);
		bus = pci_scan_root_bus(dev, 0, &advk_pcie_ops,
		pcie, &pcie->resources);
		if (!bus) {
		advk_pcie_remove_msi_irq_domain(pcie);
		advk_pcie_remove_irq_domain(pcie);

drivers/pci/host/pci-mvebu.c

+0 −17

Original line number	Diff line number	Diff line
		@@ -1006,22 +1006,6 @@ static int mvebu_get_tgt_attr(struct device_node *np, int devfn,
		return -ENOENT;
		}

		static void mvebu_pcie_msi_enable(struct mvebu_pcie *pcie)
		{
		struct device_node *msi_node;

		msi_node = of_parse_phandle(pcie->pdev->dev.of_node,
		"msi-parent", 0);
		if (!msi_node)
		return;

		pcie->msi = of_pci_find_msi_chip_by_node(msi_node);
		of_node_put(msi_node);

		if (pcie->msi)
		pcie->msi->dev = &pcie->pdev->dev;
		}

		#ifdef CONFIG_PM_SLEEP
		static int mvebu_pcie_suspend(struct device *dev)
		{
		@@ -1299,7 +1283,6 @@ static int mvebu_pcie_probe(struct platform_device *pdev)
		for (i = 0; i < (IO_SPACE_LIMIT - SZ_64K); i += SZ_64K)
		pci_ioremap_io(i, pcie->io.start + i);

		mvebu_pcie_msi_enable(pcie);
		mvebu_pcie_enable(pcie);

		platform_set_drvdata(pdev, pcie);

drivers/pci/msi.c

+6 −4

Original line number	Diff line number	Diff line
		@@ -541,7 +541,8 @@ msi_setup_entry(struct pci_dev dev, int nvec, const struct irq_affinity affd)
		if (affd) {
		masks = irq_create_affinity_masks(nvec, affd);
		if (!masks)
		pr_err("Unable to allocate affinity masks, ignoring\n");
		dev_err(&dev->dev, "can't allocate MSI affinity masks for %d vectors\n",
		nvec);
		}

		/* MSI Entry Initialization */
		@@ -681,7 +682,8 @@ static int msix_setup_entries(struct pci_dev dev, void __iomem base,
		if (affd) {
		masks = irq_create_affinity_masks(nvec, affd);
		if (!masks)
		pr_err("Unable to allocate affinity masks, ignoring\n");
		dev_err(&dev->dev, "can't allocate MSI-X affinity masks for %d vectors\n",
		nvec);
		}

		for (i = 0, curmsk = masks; i < nvec; i++) {
		@@ -882,7 +884,7 @@ int pci_msi_vec_count(struct pci_dev *dev)
		}
		EXPORT_SYMBOL(pci_msi_vec_count);

		void pci_msi_shutdown(struct pci_dev *dev)
		static void pci_msi_shutdown(struct pci_dev *dev)
		{
		struct msi_desc *desc;
		u32 mask;
		@@ -994,7 +996,7 @@ int pci_enable_msix(struct pci_dev dev, struct msix_entry entries, int nvec)
		}
		EXPORT_SYMBOL(pci_enable_msix);

		void pci_msix_shutdown(struct pci_dev *dev)
		static void pci_msix_shutdown(struct pci_dev *dev)
		{
		struct msi_desc *entry;

drivers/pci/pci-driver.c

+0 −2

Original line number	Diff line number	Diff line
		@@ -461,8 +461,6 @@ static void pci_device_shutdown(struct device *dev)

		if (drv && drv->shutdown)
		drv->shutdown(pci_dev);
		pci_msi_shutdown(pci_dev);
		pci_msix_shutdown(pci_dev);

		/*
		* If this is a kexec reboot, turn off Bus Master bit on the

Admin message