[linux-block.git] / arch / powerpc / kernel / pci_dn.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * pci_dn.c
 *
 * Copyright (C) 2001 Todd Inglett, IBM Corporation
 *
 * PCI manipulation via device_nodes.
 */
#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>
#include <asm/eeh.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,
					   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)
		return NULL;

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

	return pdn;
}
#endif

struct pci_dn *add_dev_pci_data(struct pci_dev *pdev)
{
#ifdef CONFIG_PCI_IOV
	struct pci_dn *parent, *pdn;
	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++) {
		struct eeh_dev *edev __maybe_unused;

		pdn = add_one_dev_pci_data(parent, 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;
		}

#ifdef CONFIG_EEH
		/* Create the EEH device for the VF */
		edev = eeh_dev_init(pdn);
		BUG_ON(!edev);
		edev->physfn = pdev;
#endif /* CONFIG_EEH */
	}
#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;
	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);
		pdn->pe_number = IODA_INVALID_PE;
		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++) {
		struct eeh_dev *edev __maybe_unused;

		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;

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

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

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

struct pci_dn *pci_add_device_node_info(struct pci_controller *hose,
					struct device_node *dn)
{
	const __be32 *type = of_get_property(dn, "ibm,pci-config-space-type", NULL);
	const __be32 *regs;
	struct device_node *parent;
	struct pci_dn *pdn;
#ifdef CONFIG_EEH
	struct eeh_dev *edev;
#endif

	pdn = kzalloc(sizeof(*pdn), GFP_KERNEL);
	if (pdn == NULL)
		return NULL;
	dn->data = pdn;
	pdn->phb = hose;
	pdn->pe_number = IODA_INVALID_PE;
	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);

	/* Create EEH device */
#ifdef CONFIG_EEH
	edev = eeh_dev_init(pdn);
	if (!edev) {
		kfree(pdn);
		return NULL;
	}
#endif

	/* 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 pdn;
}
EXPORT_SYMBOL_GPL(pci_add_device_node_info);

void pci_remove_device_node_info(struct device_node *dn)
{
	struct pci_dn *pdn = dn ? PCI_DN(dn) : NULL;
	struct device_node *parent;
#ifdef CONFIG_EEH
	struct eeh_dev *edev = pdn_to_eeh_dev(pdn);

	if (edev)
		edev->pdn = NULL;
#endif

	if (!pdn)
		return;

	WARN_ON(!list_empty(&pdn->child_list));
	list_del(&pdn->list);

	parent = of_get_parent(dn);
	if (parent)
		of_node_put(parent);

	dn->data = NULL;
	kfree(pdn);
}
EXPORT_SYMBOL_GPL(pci_remove_device_node_info);

/*
 * 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 *pci_traverse_device_nodes(struct device_node *start,
				void *(*fn)(struct device_node *, void *),
				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 (fn) {
			ret = fn(dn, data);
			if (ret)
				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;
}
EXPORT_SYMBOL_GPL(pci_traverse_device_nodes);

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;
}

static void *add_pdn(struct device_node *dn, void *data)
{
	struct pci_controller *hose = data;
	struct pci_dn *pdn;

	pdn = pci_add_device_node_info(hose, dn);
	if (!pdn)
		return ERR_PTR(-ENOMEM);

	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 */
	pdn = pci_add_device_node_info(phb, dn);
	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 */
	pci_traverse_device_nodes(dn, add_pdn, 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.
 */
static int __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);

	return 0;
}

core_initcall(pci_devs_phb_init);

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