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

Commit e257ef55 authored by Bjorn Helgaas's avatar Bjorn Helgaas
Browse files

Merge branches 'pci/arm64' and 'pci/host-hv' into next 

* pci/arm64:
  PCI, of: Move PCI I/O space management to PCI core code
  PCI: generic, thunder: Use generic ECAM API
  PCI: Provide common functions for ECAM mapping

* pci/host-hv:
  PCI: hv: Add explicit barriers to config space access
parents 45604e68 c5076cfe bdd74440

drivers/of/address.c

+1 −115
Original line number Diff line number Diff line
@@ -4,6 +4,7 @@ 
#include <linux/ioport.h>

#include <linux/module.h>

#include <linux/of_address.h>

#include <linux/pci.h>

#include <linux/pci_regs.h>

#include <linux/sizes.h>

#include <linux/slab.h>
@@ -673,121 +674,6 @@ const __be32 *of_get_address(struct device_node *dev, int index, u64 *size, 
}

EXPORT_SYMBOL(of_get_address);



#ifdef PCI_IOBASE

struct io_range {

	struct list_head list;

	phys_addr_t start;

	resource_size_t size;

};



static LIST_HEAD(io_range_list);

static DEFINE_SPINLOCK(io_range_lock);

#endif



/*

 * Record the PCI IO range (expressed as CPU physical address + size).

 * Return a negative value if an error has occured, zero otherwise

 */

int __weak pci_register_io_range(phys_addr_t addr, resource_size_t size)

{

	int err = 0;



#ifdef PCI_IOBASE

	struct io_range *range;

	resource_size_t allocated_size = 0;



	/* check if the range hasn't been previously recorded */

	spin_lock(&io_range_lock);

	list_for_each_entry(range, &io_range_list, list) {

		if (addr >= range->start && addr + size <= range->start + size) {

			/* range already registered, bail out */

			goto end_register;

		}

		allocated_size += range->size;

	}



	/* range not registed yet, check for available space */

	if (allocated_size + size - 1 > IO_SPACE_LIMIT) {

		/* if it's too big check if 64K space can be reserved */

		if (allocated_size + SZ_64K - 1 > IO_SPACE_LIMIT) {

			err = -E2BIG;

			goto end_register;

		}



		size = SZ_64K;

		pr_warn("Requested IO range too big, new size set to 64K\n");

	}



	/* add the range to the list */

	range = kzalloc(sizeof(*range), GFP_ATOMIC);

	if (!range) {

		err = -ENOMEM;

		goto end_register;

	}



	range->start = addr;

	range->size = size;



	list_add_tail(&range->list, &io_range_list);



end_register:

	spin_unlock(&io_range_lock);

#endif



	return err;

}



phys_addr_t pci_pio_to_address(unsigned long pio)

{

	phys_addr_t address = (phys_addr_t)OF_BAD_ADDR;



#ifdef PCI_IOBASE

	struct io_range *range;

	resource_size_t allocated_size = 0;



	if (pio > IO_SPACE_LIMIT)

		return address;



	spin_lock(&io_range_lock);

	list_for_each_entry(range, &io_range_list, list) {

		if (pio >= allocated_size && pio < allocated_size + range->size) {

			address = range->start + pio - allocated_size;

			break;

		}

		allocated_size += range->size;

	}

	spin_unlock(&io_range_lock);

#endif



	return address;

}



unsigned long __weak pci_address_to_pio(phys_addr_t address)

{

#ifdef PCI_IOBASE

	struct io_range *res;

	resource_size_t offset = 0;

	unsigned long addr = -1;



	spin_lock(&io_range_lock);

	list_for_each_entry(res, &io_range_list, list) {

		if (address >= res->start && address < res->start + res->size) {

			addr = address - res->start + offset;

			break;

		}

		offset += res->size;

	}

	spin_unlock(&io_range_lock);



	return addr;

#else

	if (address > IO_SPACE_LIMIT)

		return (unsigned long)-1;



	return (unsigned long) address;

#endif

}



static int __of_address_to_resource(struct device_node *dev,

		const __be32 *addrp, u64 size, unsigned int flags,

		const char *name, struct resource *r)

drivers/pci/Kconfig

+3 −0
Original line number Diff line number Diff line
@@ -83,6 +83,9 @@ config HT_IRQ 
config PCI_ATS

	bool



config PCI_ECAM

	bool



config PCI_IOV

	bool "PCI IOV support"

	depends on PCI

drivers/pci/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -55,6 +55,8 @@ obj-$(CONFIG_PCI_SYSCALL) += syscall.o 


obj-$(CONFIG_PCI_STUB) += pci-stub.o



obj-$(CONFIG_PCI_ECAM) += ecam.o



obj-$(CONFIG_XEN_PCIDEV_FRONTEND) += xen-pcifront.o



obj-$(CONFIG_OF) += of.o

drivers/pci/ecam.c

0 → 100644
+164 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2016 Broadcom

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License, version 2, as

 * published by the Free Software Foundation (the "GPL").

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License version 2 (GPLv2) for more details.

 *

 * You should have received a copy of the GNU General Public License

 * version 2 (GPLv2) along with this source code.

 */



#include <linux/device.h>

#include <linux/io.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/pci.h>

#include <linux/slab.h>



#include "ecam.h"



/*

 * On 64-bit systems, we do a single ioremap for the whole config space

 * since we have enough virtual address range available.  On 32-bit, we

 * ioremap the config space for each bus individually.

 */

static const bool per_bus_mapping = !config_enabled(CONFIG_64BIT);



/*

 * Create a PCI config space window

 *  - reserve mem region

 *  - alloc struct pci_config_window with space for all mappings

 *  - ioremap the config space

 */

struct pci_config_window *pci_ecam_create(struct device *dev,

		struct resource *cfgres, struct resource *busr,

		struct pci_ecam_ops *ops)

{

	struct pci_config_window *cfg;

	unsigned int bus_range, bus_range_max, bsz;

	struct resource *conflict;

	int i, err;



	if (busr->start > busr->end)

		return ERR_PTR(-EINVAL);



	cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);

	if (!cfg)

		return ERR_PTR(-ENOMEM);



	cfg->ops = ops;

	cfg->busr.start = busr->start;

	cfg->busr.end = busr->end;

	cfg->busr.flags = IORESOURCE_BUS;

	bus_range = resource_size(&cfg->busr);

	bus_range_max = resource_size(cfgres) >> ops->bus_shift;

	if (bus_range > bus_range_max) {

		bus_range = bus_range_max;

		cfg->busr.end = busr->start + bus_range - 1;

		dev_warn(dev, "ECAM area %pR can only accommodate %pR (reduced from %pR desired)\n",

			 cfgres, &cfg->busr, busr);

	}

	bsz = 1 << ops->bus_shift;



	cfg->res.start = cfgres->start;

	cfg->res.end = cfgres->end;

	cfg->res.flags = IORESOURCE_MEM | IORESOURCE_BUSY;

	cfg->res.name = "PCI ECAM";



	conflict = request_resource_conflict(&iomem_resource, &cfg->res);

	if (conflict) {

		err = -EBUSY;

		dev_err(dev, "can't claim ECAM area %pR: address conflict with %s %pR\n",

			&cfg->res, conflict->name, conflict);

		goto err_exit;

	}



	if (per_bus_mapping) {

		cfg->winp = kcalloc(bus_range, sizeof(*cfg->winp), GFP_KERNEL);

		if (!cfg->winp)

			goto err_exit_malloc;

		for (i = 0; i < bus_range; i++) {

			cfg->winp[i] = ioremap(cfgres->start + i * bsz, bsz);

			if (!cfg->winp[i])

				goto err_exit_iomap;

		}

	} else {

		cfg->win = ioremap(cfgres->start, bus_range * bsz);

		if (!cfg->win)

			goto err_exit_iomap;

	}



	if (ops->init) {

		err = ops->init(dev, cfg);

		if (err)

			goto err_exit;

	}

	dev_info(dev, "ECAM at %pR for %pR\n", &cfg->res, &cfg->busr);

	return cfg;



err_exit_iomap:

	dev_err(dev, "ECAM ioremap failed\n");

err_exit_malloc:

	err = -ENOMEM;

err_exit:

	pci_ecam_free(cfg);

	return ERR_PTR(err);

}



void pci_ecam_free(struct pci_config_window *cfg)

{

	int i;



	if (per_bus_mapping) {

		if (cfg->winp) {

			for (i = 0; i < resource_size(&cfg->busr); i++)

				if (cfg->winp[i])

					iounmap(cfg->winp[i]);

			kfree(cfg->winp);

		}

	} else {

		if (cfg->win)

			iounmap(cfg->win);

	}

	if (cfg->res.parent)

		release_resource(&cfg->res);

	kfree(cfg);

}



/*

 * Function to implement the pci_ops ->map_bus method

 */

void __iomem *pci_ecam_map_bus(struct pci_bus *bus, unsigned int devfn,

			       int where)

{

	struct pci_config_window *cfg = bus->sysdata;

	unsigned int devfn_shift = cfg->ops->bus_shift - 8;

	unsigned int busn = bus->number;

	void __iomem *base;



	if (busn < cfg->busr.start || busn > cfg->busr.end)

		return NULL;



	busn -= cfg->busr.start;

	if (per_bus_mapping)

		base = cfg->winp[busn];

	else

		base = cfg->win + (busn << cfg->ops->bus_shift);

	return base + (devfn << devfn_shift) + where;

}



/* ECAM ops */

struct pci_ecam_ops pci_generic_ecam_ops = {

	.bus_shift	= 20,

	.pci_ops	= {

		.map_bus	= pci_ecam_map_bus,

		.read		= pci_generic_config_read,

		.write		= pci_generic_config_write,

	}

};

drivers/pci/ecam.h

0 → 100644
+67 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2016 Broadcom

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License, version 2, as

 * published by the Free Software Foundation (the "GPL").

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License version 2 (GPLv2) for more details.

 *

 * You should have received a copy of the GNU General Public License

 * version 2 (GPLv2) along with this source code.

 */

#ifndef DRIVERS_PCI_ECAM_H

#define DRIVERS_PCI_ECAM_H



#include <linux/kernel.h>

#include <linux/platform_device.h>



/*

 * struct to hold pci ops and bus shift of the config window

 * for a PCI controller.

 */

struct pci_config_window;

struct pci_ecam_ops {

	unsigned int			bus_shift;

	struct pci_ops			pci_ops;

	int				(*init)(struct device *,

						struct pci_config_window *);

};



/*

 * struct to hold the mappings of a config space window. This

 * is expected to be used as sysdata for PCI controllers that

 * use ECAM.

 */

struct pci_config_window {

	struct resource			res;

	struct resource			busr;

	void				*priv;

	struct pci_ecam_ops		*ops;

	union {

		void __iomem		*win;	/* 64-bit single mapping */

		void __iomem		**winp; /* 32-bit per-bus mapping */

	};

};



/* create and free pci_config_window */

struct pci_config_window *pci_ecam_create(struct device *dev,

		struct resource *cfgres, struct resource *busr,

		struct pci_ecam_ops *ops);

void pci_ecam_free(struct pci_config_window *cfg);



/* map_bus when ->sysdata is an instance of pci_config_window */

void __iomem *pci_ecam_map_bus(struct pci_bus *bus, unsigned int devfn,

			       int where);

/* default ECAM ops */

extern struct pci_ecam_ops pci_generic_ecam_ops;



#ifdef CONFIG_PCI_HOST_GENERIC

/* for DT-based PCI controllers that support ECAM */

int pci_host_common_probe(struct platform_device *pdev,

			  struct pci_ecam_ops *ops);

#endif

#endif