[mirror_ubuntu-zesty-kernel.git] / arch / powerpc / kernel / pci_dn.c

/*
 * pci_dn.c
 *
 * Copyright (C) 2001 Todd Inglett, IBM Corporation
 *
 * PCI manipulation via device_nodes.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *    
 * 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 for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */
#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/string.h>
#include <linux/export.h>
#include <linux/init.h>
#include <linux/gfp.h>

#include <asm/io.h>
#include <asm/prom.h>
#include <asm/pci-bridge.h>
#include <asm/ppc-pci.h>
#include <asm/firmware.h>

/*
 * The function is used to find the firmware data of one
 * specific PCI device, which is attached to the indicated
 * PCI bus. For VFs, their firmware data is linked to that
 * one of PF's bridge. For other devices, their firmware
 * data is linked to that of their bridge.
 */
static struct pci_dn *pci_bus_to_pdn(struct pci_bus *bus)
{
	struct pci_bus *pbus;
	struct device_node *dn;
	struct pci_dn *pdn;

	/*
	 * We probably have virtual bus which doesn't
	 * have associated bridge.
	 */
	pbus = bus;
	while (pbus) {
		if (pci_is_root_bus(pbus) || pbus->self)
			break;

		pbus = pbus->parent;
	}

	/*
	 * Except virtual bus, all PCI buses should
	 * have device nodes.
	 */
	dn = pci_bus_to_OF_node(pbus);
	pdn = dn ? PCI_DN(dn) : NULL;

	return pdn;
}

struct pci_dn *pci_get_pdn_by_devfn(struct pci_bus *bus,
				    int devfn)
{
	struct device_node *dn = NULL;
	struct pci_dn *parent, *pdn;
	struct pci_dev *pdev = NULL;

	/* Fast path: fetch from PCI device */
	list_for_each_entry(pdev, &bus->devices, bus_list) {
		if (pdev->devfn == devfn) {
			if (pdev->dev.archdata.pci_data)
				return pdev->dev.archdata.pci_data;

			dn = pci_device_to_OF_node(pdev);
			break;
		}
	}

	/* Fast path: fetch from device node */
	pdn = dn ? PCI_DN(dn) : NULL;
	if (pdn)
		return pdn;

	/* Slow path: fetch from firmware data hierarchy */
	parent = pci_bus_to_pdn(bus);
	if (!parent)
		return NULL;

	list_for_each_entry(pdn, &parent->child_list, list) {
		if (pdn->busno == bus->number &&
                    pdn->devfn == devfn)
                        return pdn;
        }

	return NULL;
}

struct pci_dn *pci_get_pdn(struct pci_dev *pdev)
{
	struct device_node *dn;
	struct pci_dn *parent, *pdn;

	/* Search device directly */
	if (pdev->dev.archdata.pci_data)
		return pdev->dev.archdata.pci_data;

	/* Check device node */
	dn = pci_device_to_OF_node(pdev);
	pdn = dn ? PCI_DN(dn) : NULL;
	if (pdn)
		return pdn;

	/*
	 * VFs don't have device nodes. We hook their
	 * firmware data to PF's bridge.
	 */
	parent = pci_bus_to_pdn(pdev->bus);
	if (!parent)
		return NULL;

	list_for_each_entry(pdn, &parent->child_list, list) {
		if (pdn->busno == pdev->bus->number &&
		    pdn->devfn == pdev->devfn)
			return pdn;
	}

	return NULL;
}

#ifdef CONFIG_PCI_IOV
static struct pci_dn *add_one_dev_pci_data(struct pci_dn *parent,
					   struct pci_dev *pdev,
					   int vf_index,
					   int busno, int devfn)
{
	struct pci_dn *pdn;

	/* Except PHB, we always have the parent */
	if (!parent)
		return NULL;

	pdn = kzalloc(sizeof(*pdn), GFP_KERNEL);
	if (!pdn) {
		dev_warn(&pdev->dev, "%s: Out of memory!\n", __func__);
		return NULL;
	}

	pdn->phb = parent->phb;
	pdn->parent = parent;
	pdn->busno = busno;
	pdn->devfn = devfn;
#ifdef CONFIG_PPC_POWERNV
	pdn->vf_index = vf_index;
	pdn->pe_number = IODA_INVALID_PE;
#endif
	INIT_LIST_HEAD(&pdn->child_list);
	INIT_LIST_HEAD(&pdn->list);
	list_add_tail(&pdn->list, &parent->child_list);

	/*
	 * If we already have PCI device instance, lets
	 * bind them.
	 */
	if (pdev)
		pdev->dev.archdata.pci_data = pdn;

	return pdn;
}
#endif

struct pci_dn *add_dev_pci_data(struct pci_dev *pdev)
{
#ifdef CONFIG_PCI_IOV
	struct pci_dn *parent, *pdn;
	struct eeh_dev *edev;
	int i;

	/* Only support IOV for now */
	if (!pdev->is_physfn)
		return pci_get_pdn(pdev);

	/* Check if VFs have been populated */
	pdn = pci_get_pdn(pdev);
	if (!pdn || (pdn->flags & PCI_DN_FLAG_IOV_VF))
		return NULL;

	pdn->flags |= PCI_DN_FLAG_IOV_VF;
	parent = pci_bus_to_pdn(pdev->bus);
	if (!parent)
		return NULL;

	for (i = 0; i < pci_sriov_get_totalvfs(pdev); i++) {
		pdn = add_one_dev_pci_data(parent, NULL, i,
					   pci_iov_virtfn_bus(pdev, i),
					   pci_iov_virtfn_devfn(pdev, i));
		if (!pdn) {
			dev_warn(&pdev->dev, "%s: Cannot create firmware data for VF#%d\n",
				 __func__, i);
			return NULL;
		}

		/* Create the EEH device for the VF */
		eeh_dev_init(pdn, pci_bus_to_host(pdev->bus));
		edev = pdn_to_eeh_dev(pdn);
		BUG_ON(!edev);
		edev->physfn = pdev;
	}
#endif /* CONFIG_PCI_IOV */

	return pci_get_pdn(pdev);
}

void remove_dev_pci_data(struct pci_dev *pdev)
{
#ifdef CONFIG_PCI_IOV
	struct pci_dn *parent;
	struct pci_dn *pdn, *tmp;
	struct eeh_dev *edev;
	int i;

	/*
	 * VF and VF PE are created/released dynamically, so we need to
	 * bind/unbind them.  Otherwise the VF and VF PE would be mismatched
	 * when re-enabling SR-IOV.
	 */
	if (pdev->is_virtfn) {
		pdn = pci_get_pdn(pdev);
#ifdef CONFIG_PPC_POWERNV
		pdn->pe_number = IODA_INVALID_PE;
#endif
		return;
	}

	/* Only support IOV PF for now */
	if (!pdev->is_physfn)
		return;

	/* Check if VFs have been populated */
	pdn = pci_get_pdn(pdev);
	if (!pdn || !(pdn->flags & PCI_DN_FLAG_IOV_VF))
		return;

	pdn->flags &= ~PCI_DN_FLAG_IOV_VF;
	parent = pci_bus_to_pdn(pdev->bus);
	if (!parent)
		return;

	/*
	 * We might introduce flag to pci_dn in future
	 * so that we can release VF's firmware data in
	 * a batch mode.
	 */
	for (i = 0; i < pci_sriov_get_totalvfs(pdev); i++) {
		list_for_each_entry_safe(pdn, tmp,
			&parent->child_list, list) {
			if (pdn->busno != pci_iov_virtfn_bus(pdev, i) ||
			    pdn->devfn != pci_iov_virtfn_devfn(pdev, i))
				continue;

			/* Release EEH device for the VF */
			edev = pdn_to_eeh_dev(pdn);
			if (edev) {
				pdn->edev = NULL;
				kfree(edev);
			}

			if (!list_empty(&pdn->list))
				list_del(&pdn->list);

			kfree(pdn);
		}
	}
#endif /* CONFIG_PCI_IOV */
}

/*
 * Traverse_func that inits the PCI fields of the device node.
 * NOTE: this *must* be done before read/write config to the device.
 */
void *update_dn_pci_info(struct device_node *dn, void *data)
{
	struct pci_controller *phb = data;
	const __be32 *type = of_get_property(dn, "ibm,pci-config-space-type", NULL);
	const __be32 *regs;
	struct device_node *parent;
	struct pci_dn *pdn;

	pdn = zalloc_maybe_bootmem(sizeof(*pdn), GFP_KERNEL);
	if (pdn == NULL)
		return NULL;
	dn->data = pdn;
	pdn->node = dn;
	pdn->phb = phb;
#ifdef CONFIG_PPC_POWERNV
	pdn->pe_number = IODA_INVALID_PE;
#endif
	regs = of_get_property(dn, "reg", NULL);
	if (regs) {
		u32 addr = of_read_number(regs, 1);

		/* First register entry is addr (00BBSS00)  */
		pdn->busno = (addr >> 16) & 0xff;
		pdn->devfn = (addr >> 8) & 0xff;
	}

	/* vendor/device IDs and class code */
	regs = of_get_property(dn, "vendor-id", NULL);
	pdn->vendor_id = regs ? of_read_number(regs, 1) : 0;
	regs = of_get_property(dn, "device-id", NULL);
	pdn->device_id = regs ? of_read_number(regs, 1) : 0;
	regs = of_get_property(dn, "class-code", NULL);
	pdn->class_code = regs ? of_read_number(regs, 1) : 0;

	/* Extended config space */
	pdn->pci_ext_config_space = (type && of_read_number(type, 1) == 1);

	/* Attach to parent node */
	INIT_LIST_HEAD(&pdn->child_list);
	INIT_LIST_HEAD(&pdn->list);
	parent = of_get_parent(dn);
	pdn->parent = parent ? PCI_DN(parent) : NULL;
	if (pdn->parent)
		list_add_tail(&pdn->list, &pdn->parent->child_list);

	return NULL;
}

/*
 * Traverse a device tree stopping each PCI device in the tree.
 * This is done depth first.  As each node is processed, a "pre"
 * function is called and the children are processed recursively.
 *
 * The "pre" func returns a value.  If non-zero is returned from
 * the "pre" func, the traversal stops and this value is returned.
 * This return value is useful when using traverse as a method of
 * finding a device.
 *
 * NOTE: we do not run the func for devices that do not appear to
 * be PCI except for the start node which we assume (this is good
 * because the start node is often a phb which may be missing PCI
 * properties).
 * We use the class-code as an indicator. If we run into
 * one of these nodes we also assume its siblings are non-pci for
 * performance.
 */
void *traverse_pci_devices(struct device_node *start, traverse_func pre,
		void *data)
{
	struct device_node *dn, *nextdn;
	void *ret;

	/* We started with a phb, iterate all childs */
	for (dn = start->child; dn; dn = nextdn) {
		const __be32 *classp;
		u32 class = 0;

		nextdn = NULL;
		classp = of_get_property(dn, "class-code", NULL);
		if (classp)
			class = of_read_number(classp, 1);

		if (pre && ((ret = pre(dn, data)) != NULL))
			return ret;

		/* If we are a PCI bridge, go down */
		if (dn->child && ((class >> 8) == PCI_CLASS_BRIDGE_PCI ||
				  (class >> 8) == PCI_CLASS_BRIDGE_CARDBUS))
			/* Depth first...do children */
			nextdn = dn->child;
		else if (dn->sibling)
			/* ok, try next sibling instead. */
			nextdn = dn->sibling;
		if (!nextdn) {
			/* Walk up to next valid sibling. */
			do {
				dn = dn->parent;
				if (dn == start)
					return NULL;
			} while (dn->sibling == NULL);
			nextdn = dn->sibling;
		}
	}
	return NULL;
}

static struct pci_dn *pci_dn_next_one(struct pci_dn *root,
				      struct pci_dn *pdn)
{
	struct list_head *next = pdn->child_list.next;

	if (next != &pdn->child_list)
		return list_entry(next, struct pci_dn, list);

	while (1) {
		if (pdn == root)
			return NULL;

		next = pdn->list.next;
		if (next != &pdn->parent->child_list)
			break;

		pdn = pdn->parent;
	}

	return list_entry(next, struct pci_dn, list);
}

void *traverse_pci_dn(struct pci_dn *root,
		      void *(*fn)(struct pci_dn *, void *),
		      void *data)
{
	struct pci_dn *pdn = root;
	void *ret;

	/* Only scan the child nodes */
	for (pdn = pci_dn_next_one(root, pdn); pdn;
	     pdn = pci_dn_next_one(root, pdn)) {
		ret = fn(pdn, data);
		if (ret)
			return ret;
	}

	return NULL;
}

/** 
 * pci_devs_phb_init_dynamic - setup pci devices under this PHB
 * phb: pci-to-host bridge (top-level bridge connecting to cpu)
 *
 * This routine is called both during boot, (before the memory
 * subsystem is set up, before kmalloc is valid) and during the 
 * dynamic lpar operation of adding a PHB to a running system.
 */
void pci_devs_phb_init_dynamic(struct pci_controller *phb)
{
	struct device_node *dn = phb->dn;
	struct pci_dn *pdn;

	/* PHB nodes themselves must not match */
	update_dn_pci_info(dn, phb);
	pdn = dn->data;
	if (pdn) {
		pdn->devfn = pdn->busno = -1;
		pdn->vendor_id = pdn->device_id = pdn->class_code = 0;
		pdn->phb = phb;
		phb->pci_data = pdn;
	}

	/* Update dn->phb ptrs for new phb and children devices */
	traverse_pci_devices(dn, update_dn_pci_info, phb);
}

/** 
 * pci_devs_phb_init - Initialize phbs and pci devs under them.
 * 
 * This routine walks over all phb's (pci-host bridges) on the
 * system, and sets up assorted pci-related structures 
 * (including pci info in the device node structs) for each
 * pci device found underneath.  This routine runs once,
 * early in the boot sequence.
 */
void __init pci_devs_phb_init(void)
{
	struct pci_controller *phb, *tmp;

	/* This must be done first so the device nodes have valid pci info! */
	list_for_each_entry_safe(phb, tmp, &hose_list, list_node)
		pci_devs_phb_init_dynamic(phb);
}

static void pci_dev_pdn_setup(struct pci_dev *pdev)
{
	struct pci_dn *pdn;

	if (pdev->dev.archdata.pci_data)
		return;

	/* Setup the fast path */
	pdn = pci_get_pdn(pdev);
	pdev->dev.archdata.pci_data = pdn;
}
DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID, PCI_ANY_ID, pci_dev_pdn_setup);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* pci_dn.c
	3	*
	4	* Copyright (C) 2001 Todd Inglett, IBM Corporation
	5	*
	6	* PCI manipulation via device_nodes.
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	21	*/
	22	#include <linux/kernel.h>
	23	#include <linux/pci.h>
	24	#include <linux/string.h>
66b15db6	25	#include <linux/export.h>
1da177e4	26	#include <linux/init.h>
5a0e3ad6	27	#include <linux/gfp.h>
1da177e4 LT	28
	29	#include <asm/io.h>
	30	#include <asm/prom.h>
	31	#include <asm/pci-bridge.h>
d387899f	32	#include <asm/ppc-pci.h>
095eed4f	33	#include <asm/firmware.h>
1da177e4	34
cca87d30 GS	35	/*
	36	* The function is used to find the firmware data of one
	37	* specific PCI device, which is attached to the indicated
	38	* PCI bus. For VFs, their firmware data is linked to that
	39	* one of PF's bridge. For other devices, their firmware
	40	* data is linked to that of their bridge.
	41	*/
	42	static struct pci_dn pci_bus_to_pdn(struct pci_bus bus)
	43	{
	44	struct pci_bus *pbus;
	45	struct device_node *dn;
	46	struct pci_dn *pdn;
	47
	48	/*
	49	* We probably have virtual bus which doesn't
	50	* have associated bridge.
	51	*/
	52	pbus = bus;
	53	while (pbus) {
	54	if (pci_is_root_bus(pbus) \|\| pbus->self)
	55	break;
	56
	57	pbus = pbus->parent;
	58	}
	59
	60	/*
	61	* Except virtual bus, all PCI buses should
	62	* have device nodes.
	63	*/
	64	dn = pci_bus_to_OF_node(pbus);
	65	pdn = dn ? PCI_DN(dn) : NULL;
	66
	67	return pdn;
	68	}
	69
	70	struct pci_dn pci_get_pdn_by_devfn(struct pci_bus bus,
	71	int devfn)
	72	{
	73	struct device_node *dn = NULL;
	74	struct pci_dn parent, pdn;
	75	struct pci_dev *pdev = NULL;
	76
	77	/* Fast path: fetch from PCI device */
	78	list_for_each_entry(pdev, &bus->devices, bus_list) {
	79	if (pdev->devfn == devfn) {
	80	if (pdev->dev.archdata.pci_data)
	81	return pdev->dev.archdata.pci_data;
	82
	83	dn = pci_device_to_OF_node(pdev);
	84	break;
	85	}
	86	}
	87
	88	/* Fast path: fetch from device node */
	89	pdn = dn ? PCI_DN(dn) : NULL;
	90	if (pdn)
	91	return pdn;
	92
	93	/* Slow path: fetch from firmware data hierarchy */
	94	parent = pci_bus_to_pdn(bus);
	95	if (!parent)
	96	return NULL;
	97
	98	list_for_each_entry(pdn, &parent->child_list, list) {
99	if (pdn->busno == bus->number &&
100	pdn->devfn == devfn)
101	return pdn;
102	}
103
104	return NULL;
105	}
106
b72c1f65 BH	107	struct pci_dn pci_get_pdn(struct pci_dev pdev)
b72c1f65 BH	108	{
cca87d30 GS	109	struct device_node *dn;
	110	struct pci_dn parent, pdn;
	111
	112	/* Search device directly */
	113	if (pdev->dev.archdata.pci_data)
	114	return pdev->dev.archdata.pci_data;
	115
	116	/* Check device node */
	117	dn = pci_device_to_OF_node(pdev);
	118	pdn = dn ? PCI_DN(dn) : NULL;
	119	if (pdn)
	120	return pdn;
	121
	122	/*
	123	* VFs don't have device nodes. We hook their
	124	* firmware data to PF's bridge.
	125	*/
	126	parent = pci_bus_to_pdn(pdev->bus);
	127	if (!parent)
b72c1f65	128	return NULL;
cca87d30 GS	129
	130	list_for_each_entry(pdn, &parent->child_list, list) {
	131	if (pdn->busno == pdev->bus->number &&
	132	pdn->devfn == pdev->devfn)
	133	return pdn;
	134	}
	135
	136	return NULL;
b72c1f65 BH	137	}
b72c1f65 BH	138
a8b2f828 GS	139	#ifdef CONFIG_PCI_IOV
	140	static struct pci_dn add_one_dev_pci_data(struct pci_dn parent,
	141	struct pci_dev *pdev,
67086e32	142	int vf_index,
a8b2f828 GS	143	int busno, int devfn)
	144	{
	145	struct pci_dn *pdn;
	146
	147	/* Except PHB, we always have the parent */
	148	if (!parent)
	149	return NULL;
	150
	151	pdn = kzalloc(sizeof(*pdn), GFP_KERNEL);
	152	if (!pdn) {
	153	dev_warn(&pdev->dev, "%s: Out of memory!\n", __func__);
	154	return NULL;
	155	}
	156
	157	pdn->phb = parent->phb;
	158	pdn->parent = parent;
	159	pdn->busno = busno;
	160	pdn->devfn = devfn;
	161	#ifdef CONFIG_PPC_POWERNV
67086e32	162	pdn->vf_index = vf_index;
a8b2f828 GS	163	pdn->pe_number = IODA_INVALID_PE;
	164	#endif
	165	INIT_LIST_HEAD(&pdn->child_list);
	166	INIT_LIST_HEAD(&pdn->list);
	167	list_add_tail(&pdn->list, &parent->child_list);
	168
	169	/*
	170	* If we already have PCI device instance, lets
	171	* bind them.
	172	*/
	173	if (pdev)
	174	pdev->dev.archdata.pci_data = pdn;
	175
	176	return pdn;
	177	}
	178	#endif
	179
	180	struct pci_dn add_dev_pci_data(struct pci_dev pdev)
	181	{
	182	#ifdef CONFIG_PCI_IOV
	183	struct pci_dn parent, pdn;
39218cd0	184	struct eeh_dev *edev;
a8b2f828 GS	185	int i;
	186
	187	/* Only support IOV for now */
	188	if (!pdev->is_physfn)
	189	return pci_get_pdn(pdev);
	190
	191	/* Check if VFs have been populated */
	192	pdn = pci_get_pdn(pdev);
	193	if (!pdn \|\| (pdn->flags & PCI_DN_FLAG_IOV_VF))
	194	return NULL;
	195
	196	pdn->flags \|= PCI_DN_FLAG_IOV_VF;
	197	parent = pci_bus_to_pdn(pdev->bus);
	198	if (!parent)
	199	return NULL;
	200
	201	for (i = 0; i < pci_sriov_get_totalvfs(pdev); i++) {
67086e32	202	pdn = add_one_dev_pci_data(parent, NULL, i,
a8b2f828 GS	203	pci_iov_virtfn_bus(pdev, i),
	204	pci_iov_virtfn_devfn(pdev, i));
	205	if (!pdn) {
	206	dev_warn(&pdev->dev, "%s: Cannot create firmware data for VF#%d\n",
	207	__func__, i);
	208	return NULL;
	209	}
39218cd0 WY	210
	211	/* Create the EEH device for the VF */
	212	eeh_dev_init(pdn, pci_bus_to_host(pdev->bus));
	213	edev = pdn_to_eeh_dev(pdn);
	214	BUG_ON(!edev);
	215	edev->physfn = pdev;
a8b2f828 GS	216	}
	217	#endif /* CONFIG_PCI_IOV */
	218
	219	return pci_get_pdn(pdev);
	220	}
	221
	222	void remove_dev_pci_data(struct pci_dev *pdev)
	223	{
	224	#ifdef CONFIG_PCI_IOV
	225	struct pci_dn *parent;
	226	struct pci_dn pdn, tmp;
39218cd0	227	struct eeh_dev *edev;
a8b2f828 GS	228	int i;
a8b2f828 GS	229
781a868f WY	230	/*
	231	* VF and VF PE are created/released dynamically, so we need to
	232	* bind/unbind them. Otherwise the VF and VF PE would be mismatched
	233	* when re-enabling SR-IOV.
	234	*/
	235	if (pdev->is_virtfn) {
	236	pdn = pci_get_pdn(pdev);
	237	#ifdef CONFIG_PPC_POWERNV
	238	pdn->pe_number = IODA_INVALID_PE;
	239	#endif
	240	return;
	241	}
	242
a8b2f828 GS	243	/* Only support IOV PF for now */
	244	if (!pdev->is_physfn)
	245	return;
	246
	247	/* Check if VFs have been populated */
	248	pdn = pci_get_pdn(pdev);
	249	if (!pdn \|\| !(pdn->flags & PCI_DN_FLAG_IOV_VF))
	250	return;
	251
	252	pdn->flags &= ~PCI_DN_FLAG_IOV_VF;
	253	parent = pci_bus_to_pdn(pdev->bus);
	254	if (!parent)
	255	return;
	256
	257	/*
	258	* We might introduce flag to pci_dn in future
	259	* so that we can release VF's firmware data in
	260	* a batch mode.
	261	*/
	262	for (i = 0; i < pci_sriov_get_totalvfs(pdev); i++) {
	263	list_for_each_entry_safe(pdn, tmp,
	264	&parent->child_list, list) {
	265	if (pdn->busno != pci_iov_virtfn_bus(pdev, i) \|\|
	266	pdn->devfn != pci_iov_virtfn_devfn(pdev, i))
	267	continue;
	268
39218cd0 WY	269	/* Release EEH device for the VF */
	270	edev = pdn_to_eeh_dev(pdn);
	271	if (edev) {
	272	pdn->edev = NULL;
	273	kfree(edev);
	274	}
	275
a8b2f828 GS	276	if (!list_empty(&pdn->list))
	277	list_del(&pdn->list);
	278
	279	kfree(pdn);
	280	}
	281	}
	282	#endif /* CONFIG_PCI_IOV */
	283	}
	284
1da177e4 LT	285	/*
	286	* Traverse_func that inits the PCI fields of the device node.
	287	* NOTE: this must be done before read/write config to the device.
	288	*/
cad5cef6	289	void update_dn_pci_info(struct device_node dn, void *data)
1da177e4 LT	290	{
1da177e4 LT	291	struct pci_controller *phb = data;
c6296b96 AB	292	const __be32 *type = of_get_property(dn, "ibm,pci-config-space-type", NULL);
c6296b96 AB	293	const __be32 *regs;
cca87d30	294	struct device_node *parent;
1635317f PM	295	struct pci_dn *pdn;
1635317f PM	296
a56555e5	297	pdn = zalloc_maybe_bootmem(sizeof(*pdn), GFP_KERNEL);
1635317f PM	298	if (pdn == NULL)
1635317f PM	299	return NULL;
1635317f PM	300	dn->data = pdn;
	301	pdn->node = dn;
	302	pdn->phb = phb;
184cd4a3 BH	303	#ifdef CONFIG_PPC_POWERNV
	304	pdn->pe_number = IODA_INVALID_PE;
	305	#endif
e2eb6392	306	regs = of_get_property(dn, "reg", NULL);
1da177e4	307	if (regs) {
c6296b96 AB	308	u32 addr = of_read_number(regs, 1);
c6296b96 AB	309
1da177e4	310	/* First register entry is addr (00BBSS00) */
c6296b96 AB	311	pdn->busno = (addr >> 16) & 0xff;
c6296b96 AB	312	pdn->devfn = (addr >> 8) & 0xff;
1da177e4 LT	313	}
1da177e4 LT	314
c035ff1d GS	315	/* vendor/device IDs and class code */
	316	regs = of_get_property(dn, "vendor-id", NULL);
	317	pdn->vendor_id = regs ? of_read_number(regs, 1) : 0;
	318	regs = of_get_property(dn, "device-id", NULL);
	319	pdn->device_id = regs ? of_read_number(regs, 1) : 0;
	320	regs = of_get_property(dn, "class-code", NULL);
	321	pdn->class_code = regs ? of_read_number(regs, 1) : 0;
	322
	323	/* Extended config space */
c6296b96	324	pdn->pci_ext_config_space = (type && of_read_number(type, 1) == 1);
cca87d30 GS	325
	326	/* Attach to parent node */
	327	INIT_LIST_HEAD(&pdn->child_list);
	328	INIT_LIST_HEAD(&pdn->list);
	329	parent = of_get_parent(dn);
	330	pdn->parent = parent ? PCI_DN(parent) : NULL;
	331	if (pdn->parent)
	332	list_add_tail(&pdn->list, &pdn->parent->child_list);
	333
1da177e4 LT	334	return NULL;
	335	}
	336
	337	/*
	338	* Traverse a device tree stopping each PCI device in the tree.
	339	* This is done depth first. As each node is processed, a "pre"
	340	* function is called and the children are processed recursively.
	341	*
	342	* The "pre" func returns a value. If non-zero is returned from
	343	* the "pre" func, the traversal stops and this value is returned.
	344	* This return value is useful when using traverse as a method of
	345	* finding a device.
	346	*
	347	* NOTE: we do not run the func for devices that do not appear to
	348	* be PCI except for the start node which we assume (this is good
	349	* because the start node is often a phb which may be missing PCI
	350	* properties).
	351	* We use the class-code as an indicator. If we run into
	352	* one of these nodes we also assume its siblings are non-pci for
	353	* performance.
	354	*/
	355	void traverse_pci_devices(struct device_node start, traverse_func pre,
	356	void *data)
	357	{
	358	struct device_node dn, nextdn;
	359	void *ret;
	360
	361	/* We started with a phb, iterate all childs */
	362	for (dn = start->child; dn; dn = nextdn) {
c6296b96 AB	363	const __be32 *classp;
c6296b96 AB	364	u32 class = 0;
1da177e4 LT	365
1da177e4 LT	366	nextdn = NULL;
e2eb6392	367	classp = of_get_property(dn, "class-code", NULL);
c6296b96 AB	368	if (classp)
c6296b96 AB	369	class = of_read_number(classp, 1);
1da177e4 LT	370
	371	if (pre && ((ret = pre(dn, data)) != NULL))
	372	return ret;
	373
	374	/* If we are a PCI bridge, go down */
	375	if (dn->child && ((class >> 8) == PCI_CLASS_BRIDGE_PCI \|\|
	376	(class >> 8) == PCI_CLASS_BRIDGE_CARDBUS))
	377	/* Depth first...do children */
	378	nextdn = dn->child;
	379	else if (dn->sibling)
	380	/* ok, try next sibling instead. */
	381	nextdn = dn->sibling;
	382	if (!nextdn) {
	383	/* Walk up to next valid sibling. */
	384	do {
	385	dn = dn->parent;
	386	if (dn == start)
	387	return NULL;
	388	} while (dn->sibling == NULL);
	389	nextdn = dn->sibling;
	390	}
	391	}
	392	return NULL;
	393	}
	394
e8e9b34c GS	395	static struct pci_dn pci_dn_next_one(struct pci_dn root,
	396	struct pci_dn *pdn)
	397	{
	398	struct list_head *next = pdn->child_list.next;
	399
	400	if (next != &pdn->child_list)
	401	return list_entry(next, struct pci_dn, list);
	402
	403	while (1) {
	404	if (pdn == root)
	405	return NULL;
	406
	407	next = pdn->list.next;
	408	if (next != &pdn->parent->child_list)
	409	break;
	410
	411	pdn = pdn->parent;
	412	}
	413
	414	return list_entry(next, struct pci_dn, list);
	415	}
	416
	417	void traverse_pci_dn(struct pci_dn root,
	418	void (fn)(struct pci_dn , void ),
	419	void *data)
	420	{
	421	struct pci_dn *pdn = root;
	422	void *ret;
	423
	424	/* Only scan the child nodes */
	425	for (pdn = pci_dn_next_one(root, pdn); pdn;
	426	pdn = pci_dn_next_one(root, pdn)) {
	427	ret = fn(pdn, data);
	428	if (ret)
	429	return ret;
	430	}
	431
	432	return NULL;
	433	}
	434
18126f35 LV	435	/**
	436	* pci_devs_phb_init_dynamic - setup pci devices under this PHB
	437	* phb: pci-to-host bridge (top-level bridge connecting to cpu)
	438	*
	439	* This routine is called both during boot, (before the memory
	440	* subsystem is set up, before kmalloc is valid) and during the
	441	* dynamic lpar operation of adding a PHB to a running system.
	442	*/
cad5cef6	443	void pci_devs_phb_init_dynamic(struct pci_controller *phb)
1da177e4	444	{
44ef3390	445	struct device_node *dn = phb->dn;
1635317f	446	struct pci_dn *pdn;
1da177e4 LT	447
1da177e4 LT	448	/* PHB nodes themselves must not match */
1635317f PM	449	update_dn_pci_info(dn, phb);
1635317f PM	450	pdn = dn->data;
cca87d30	451	if (pdn) {
1635317f	452	pdn->devfn = pdn->busno = -1;
c035ff1d	453	pdn->vendor_id = pdn->device_id = pdn->class_code = 0;
cca87d30 GS	454	pdn->phb = phb;
	455	phb->pci_data = pdn;
	456	}
1da177e4 LT	457
	458	/* Update dn->phb ptrs for new phb and children devices */
	459	traverse_pci_devices(dn, update_dn_pci_info, phb);
	460	}
	461
18126f35 LV	462	/**
	463	* pci_devs_phb_init - Initialize phbs and pci devs under them.
	464	*
	465	* This routine walks over all phb's (pci-host bridges) on the
	466	* system, and sets up assorted pci-related structures
	467	* (including pci info in the device node structs) for each
	468	* pci device found underneath. This routine runs once,
	469	* early in the boot sequence.
1da177e4 LT	470	*/
	471	void __init pci_devs_phb_init(void)
	472	{
	473	struct pci_controller phb, tmp;
	474
	475	/* This must be done first so the device nodes have valid pci info! */
	476	list_for_each_entry_safe(phb, tmp, &hose_list, list_node)
	477	pci_devs_phb_init_dynamic(phb);
1da177e4	478	}
cca87d30 GS	479
	480	static void pci_dev_pdn_setup(struct pci_dev *pdev)
	481	{
	482	struct pci_dn *pdn;
	483
	484	if (pdev->dev.archdata.pci_data)
	485	return;
	486
	487	/* Setup the fast path */
	488	pdn = pci_get_pdn(pdev);
	489	pdev->dev.archdata.pci_data = pdn;
	490	}
	491	DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID, PCI_ANY_ID, pci_dev_pdn_setup);