[SPARC64]: Convert sparc64 PCI layer to in-kernel device tree. (de8d28b1) · Commits · e / devices / android_kernel_fairphone_FP3

arch/sparc64/kernel/ebus.c

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -553,7 +553,7 @@ void __init ebus_init(void)
	}		}

	cookie = pdev->sysdata;		cookie = pdev->sysdata;
	ebusnd = cookie->prom_node;		ebusnd = cookie->prom_node->node;

	ebus_chain = ebus = ebus_alloc(sizeof(struct linux_ebus));		ebus_chain = ebus = ebus_alloc(sizeof(struct linux_ebus));
	ebus->next = NULL;		ebus->next = NULL;
	@@ -578,7 +578,7 @@ void __init ebus_init(void)
	}		}
	ebus->is_rio = is_rio;		ebus->is_rio = is_rio;
	cookie = pdev->sysdata;		cookie = pdev->sysdata;
	ebusnd = cookie->prom_node;		ebusnd = cookie->prom_node->node;
	continue;		continue;
	}		}
	printk("ebus%d:", num_ebus);		printk("ebus%d:", num_ebus);
	@@ -622,7 +622,7 @@ void __init ebus_init(void)
	break;		break;

	cookie = pdev->sysdata;		cookie = pdev->sysdata;
	ebusnd = cookie->prom_node;		ebusnd = cookie->prom_node->node;

	ebus->next = ebus_alloc(sizeof(struct linux_ebus));		ebus->next = ebus_alloc(sizeof(struct linux_ebus));
	ebus = ebus->next;		ebus = ebus->next;

arch/sparc64/kernel/isa.c

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -291,8 +291,8 @@ void __init isa_init(void)
	isa_br->parent = pbm;		isa_br->parent = pbm;
	isa_br->self = pdev;		isa_br->self = pdev;
	isa_br->index = index++;		isa_br->index = index++;
	isa_br->prom_node = pdev_cookie->prom_node;		isa_br->prom_node = pdev_cookie->prom_node->node;
	strncpy(isa_br->prom_name, pdev_cookie->prom_name,		strncpy(isa_br->prom_name, pdev_cookie->prom_node->name,
	sizeof(isa_br->prom_name));		sizeof(isa_br->prom_name));

	prop_len = prom_getproperty(isa_br->prom_node,		prop_len = prom_getproperty(isa_br->prom_node,

arch/sparc64/kernel/pci_common.c

+103 −93

Original line number	Original line	Diff line number	Diff line
	@@ -9,6 +9,9 @@
	#include <linux/init.h>		#include <linux/init.h>

	#include <asm/pbm.h>		#include <asm/pbm.h>
			#include <asm/prom.h>

			#include "pci_impl.h"

	/* Pass "pci=irq_verbose" on the kernel command line to enable this. */		/* Pass "pci=irq_verbose" on the kernel command line to enable this. */
	int pci_irq_verbose;		int pci_irq_verbose;
	@@ -31,16 +34,14 @@ void __init pci_fixup_host_bridge_self(struct pci_bus *pbus)
	prom_halt();		prom_halt();
	}		}

	/* Find the OBP PROM device tree node for a PCI device.		/* Find the OBP PROM device tree node for a PCI device. */
	* Return zero if not found.		static struct device_node * __init
	*/		find_device_prom_node(struct pci_pbm_info pbm, struct pci_dev pdev,
	static int __init find_device_prom_node(struct pci_pbm_info *pbm,		struct device_node *bus_node,
	struct pci_dev *pdev,		struct linux_prom_pci_registers **pregs,
	int bus_prom_node,
	struct linux_prom_pci_registers *pregs,
	int *nregs)		int *nregs)
	{		{
	int node;		struct device_node *dp;

	*nregs = 0;		*nregs = 0;

	@@ -57,24 +58,30 @@ static int __init find_device_prom_node(struct pci_pbm_info *pbm,
	pdev->device == PCI_DEVICE_ID_SUN_TOMATILLO \|\|		pdev->device == PCI_DEVICE_ID_SUN_TOMATILLO \|\|
	pdev->device == PCI_DEVICE_ID_SUN_SABRE \|\|		pdev->device == PCI_DEVICE_ID_SUN_SABRE \|\|
	pdev->device == PCI_DEVICE_ID_SUN_HUMMINGBIRD))		pdev->device == PCI_DEVICE_ID_SUN_HUMMINGBIRD))
	return bus_prom_node;		return bus_node;

	node = prom_getchild(bus_prom_node);		dp = bus_node->child;
	while (node != 0) {		while (dp) {
	int err = prom_getproperty(node, "reg",		struct linux_prom_pci_registers *regs;
	(char *)pregs,		struct property *prop;
	sizeof(pregs) PROMREG_MAX);		int len;
	if (err == 0 \|\| err == -1)
			prop = of_find_property(dp, "reg", &len);
			if (!prop)
	goto do_next_sibling;		goto do_next_sibling;
	if (((pregs[0].phys_hi >> 8) & 0xff) == pdev->devfn) {
	nregs = err / sizeof(pregs);		regs = prop->value;
	return node;		if (((regs[0].phys_hi >> 8) & 0xff) == pdev->devfn) {
			*pregs = regs;
			*nregs = len / sizeof(struct linux_prom_pci_registers);
			return dp;
	}		}

	do_next_sibling:		do_next_sibling:
	node = prom_getsibling(node);		dp = dp->sibling;
	}		}
	return 0;
			return NULL;
	}		}

	/* Older versions of OBP on PCI systems encode 64-bit MEM		/* Older versions of OBP on PCI systems encode 64-bit MEM
	@@ -131,15 +138,17 @@ static void __init fixup_obp_assignments(struct pci_dev *pdev,
	*/		*/
	static void __init pdev_cookie_fillin(struct pci_pbm_info *pbm,		static void __init pdev_cookie_fillin(struct pci_pbm_info *pbm,
	struct pci_dev *pdev,		struct pci_dev *pdev,
	int bus_prom_node)		struct device_node *bus_node)
	{		{
	struct linux_prom_pci_registers pregs[PROMREG_MAX];		struct linux_prom_pci_registers *pregs = NULL;
	struct pcidev_cookie *pcp;		struct pcidev_cookie *pcp;
	int device_prom_node, nregs, err;		struct device_node *dp;
			struct property *prop;
			int nregs, len;

	device_prom_node = find_device_prom_node(pbm, pdev, bus_prom_node,		dp = find_device_prom_node(pbm, pdev, bus_node,
	pregs, &nregs);		&pregs, &nregs);
	if (device_prom_node == 0) {		if (!dp) {
	/* If it is not in the OBP device tree then		/* If it is not in the OBP device tree then
	* there must be a damn good reason for it.		* there must be a damn good reason for it.
	*		*
	@@ -153,45 +162,43 @@ static void __init pdev_cookie_fillin(struct pci_pbm_info *pbm,
	return;		return;
	}		}

	pcp = kmalloc(sizeof(*pcp), GFP_ATOMIC);		pcp = kzalloc(sizeof(*pcp), GFP_ATOMIC);
	if (pcp == NULL) {		if (pcp == NULL) {
	prom_printf("PCI_COOKIE: Fatal malloc error, aborting...\n");		prom_printf("PCI_COOKIE: Fatal malloc error, aborting...\n");
	prom_halt();		prom_halt();
	}		}
	pcp->pbm = pbm;		pcp->pbm = pbm;
	pcp->prom_node = device_prom_node;		pcp->prom_node = dp;
	memcpy(pcp->prom_regs, pregs, sizeof(pcp->prom_regs));		memcpy(pcp->prom_regs, pregs,
			nregs * sizeof(struct linux_prom_pci_registers));
	pcp->num_prom_regs = nregs;		pcp->num_prom_regs = nregs;
	err = prom_getproperty(device_prom_node, "name",
	pcp->prom_name, sizeof(pcp->prom_name));
	if (err > 0)
	pcp->prom_name[err] = 0;
	else
	pcp->prom_name[0] = 0;

	err = prom_getproperty(device_prom_node,		/* We can't have the pcidev_cookie assignments be just
	"assigned-addresses",		* direct pointers into the property value, since they
	(char *)pcp->prom_assignments,		* are potentially modified by the probing process.
	sizeof(pcp->prom_assignments));		*/
	if (err == 0 \|\| err == -1)		prop = of_find_property(dp, "assigned-addresses", &len);
			if (!prop) {
	pcp->num_prom_assignments = 0;		pcp->num_prom_assignments = 0;
	else		} else {
			memcpy(pcp->prom_assignments, prop->value, len);
	pcp->num_prom_assignments =		pcp->num_prom_assignments =
	(err / sizeof(pcp->prom_assignments[0]));		(len / sizeof(pcp->prom_assignments[0]));
			}

	if (strcmp(pcp->prom_name, "ebus") == 0) {		if (strcmp(dp->name, "ebus") == 0) {
	struct linux_prom_ebus_ranges erng[PROM_PCIRNG_MAX];		struct linux_prom_ebus_ranges *erng;
	int iter;		int iter;

	/* EBUS is special... */		/* EBUS is special... */
	err = prom_getproperty(device_prom_node, "ranges",		prop = of_find_property(dp, "ranges", &len);
	(char *)&erng[0], sizeof(erng));		if (!prop) {
	if (err == 0 \|\| err == -1) {
	prom_printf("EBUS: Fatal error, no range property\n");		prom_printf("EBUS: Fatal error, no range property\n");
	prom_halt();		prom_halt();
	}		}
	err = (err / sizeof(erng[0]));		erng = prop->value;
	for(iter = 0; iter < err; iter++) {		len = (len / sizeof(erng[0]));
			for (iter = 0; iter < len; iter++) {
	struct linux_prom_ebus_ranges *ep = &erng[iter];		struct linux_prom_ebus_ranges *ep = &erng[iter];
	struct linux_prom_pci_registers *ap;		struct linux_prom_pci_registers *ap;

	@@ -203,7 +210,7 @@ static void __init pdev_cookie_fillin(struct pci_pbm_info *pbm,
	ap->size_hi = 0;		ap->size_hi = 0;
	ap->size_lo = ep->size;		ap->size_lo = ep->size;
	}		}
	pcp->num_prom_assignments = err;		pcp->num_prom_assignments = len;
	}		}

	fixup_obp_assignments(pdev, pcp);		fixup_obp_assignments(pdev, pcp);
	@@ -213,7 +220,7 @@ static void __init pdev_cookie_fillin(struct pci_pbm_info *pbm,

	void __init pci_fill_in_pbm_cookies(struct pci_bus *pbus,		void __init pci_fill_in_pbm_cookies(struct pci_bus *pbus,
	struct pci_pbm_info *pbm,		struct pci_pbm_info *pbm,
	int prom_node)		struct device_node *dp)
	{		{
	struct pci_dev pdev, pdev_next;		struct pci_dev pdev, pdev_next;
	struct pci_bus this_pbus, pbus_next;		struct pci_bus this_pbus, pbus_next;
	@@ -221,7 +228,7 @@ void __init pci_fill_in_pbm_cookies(struct pci_bus *pbus,
	/* This must be _safe because the cookie fillin		/* This must be _safe because the cookie fillin
	routine can delete devices from the tree. */		routine can delete devices from the tree. */
	list_for_each_entry_safe(pdev, pdev_next, &pbus->devices, bus_list)		list_for_each_entry_safe(pdev, pdev_next, &pbus->devices, bus_list)
	pdev_cookie_fillin(pbm, pdev, prom_node);		pdev_cookie_fillin(pbm, pdev, dp);

	list_for_each_entry_safe(this_pbus, pbus_next, &pbus->children, node) {		list_for_each_entry_safe(this_pbus, pbus_next, &pbus->children, node) {
	struct pcidev_cookie *pcp = this_pbus->self->sysdata;		struct pcidev_cookie *pcp = this_pbus->self->sysdata;
	@@ -244,7 +251,6 @@ static void __init bad_assignment(struct pci_dev *pdev,
	if (res)		if (res)
	prom_printf("PCI: RES[%016lx-->%016lx:(%lx)]\n",		prom_printf("PCI: RES[%016lx-->%016lx:(%lx)]\n",
	res->start, res->end, res->flags);		res->start, res->end, res->flags);
	prom_printf("Please email this information to davem@redhat.com\n");
	if (do_prom_halt)		if (do_prom_halt)
	prom_halt();		prom_halt();
	}		}
	@@ -276,8 +282,7 @@ __init get_root_resource(struct linux_prom_pci_registers *ap,
	return &pbm->mem_space;		return &pbm->mem_space;

	default:		default:
	printk("PCI: What is resource space %x? "		printk("PCI: What is resource space %x?\n", space);
	"Tell davem@redhat.com about it!\n", space);
	return NULL;		return NULL;
	};		};
	}		}
	@@ -572,50 +577,51 @@ static inline unsigned int pci_apply_intmap(struct pci_pbm_info *pbm,
	struct pci_dev *pbus,		struct pci_dev *pbus,
	struct pci_dev *pdev,		struct pci_dev *pdev,
	unsigned int interrupt,		unsigned int interrupt,
	unsigned int *cnode)		struct device_node **cnode)
	{		{
	struct linux_prom_pci_intmap imap[PROM_PCIIMAP_MAX];		struct linux_prom_pci_intmap *imap;
	struct linux_prom_pci_intmask imask;		struct linux_prom_pci_intmask *imask;
	struct pcidev_cookie *pbus_pcp = pbus->sysdata;		struct pcidev_cookie *pbus_pcp = pbus->sysdata;
	struct pcidev_cookie *pdev_pcp = pdev->sysdata;		struct pcidev_cookie *pdev_pcp = pdev->sysdata;
	struct linux_prom_pci_registers *pregs = pdev_pcp->prom_regs;		struct linux_prom_pci_registers *pregs = pdev_pcp->prom_regs;
			struct property *prop;
	int plen, num_imap, i;		int plen, num_imap, i;
	unsigned int hi, mid, lo, irq, orig_interrupt;		unsigned int hi, mid, lo, irq, orig_interrupt;

	*cnode = pbus_pcp->prom_node;		*cnode = pbus_pcp->prom_node;

	plen = prom_getproperty(pbus_pcp->prom_node, "interrupt-map",		prop = of_find_property(pbus_pcp->prom_node, "interrupt-map", &plen);
	(char *) &imap[0], sizeof(imap));		if (!prop \|\|
	if (plen <= 0 \|\|
	(plen % sizeof(struct linux_prom_pci_intmap)) != 0) {		(plen % sizeof(struct linux_prom_pci_intmap)) != 0) {
	printk("%s: Device %s interrupt-map has bad len %d\n",		printk("%s: Device %s interrupt-map has bad len %d\n",
	pbm->name, pci_name(pbus), plen);		pbm->name, pci_name(pbus), plen);
	goto no_intmap;		goto no_intmap;
	}		}
			imap = prop->value;
	num_imap = plen / sizeof(struct linux_prom_pci_intmap);		num_imap = plen / sizeof(struct linux_prom_pci_intmap);

	plen = prom_getproperty(pbus_pcp->prom_node, "interrupt-map-mask",		prop = of_find_property(pbus_pcp->prom_node, "interrupt-map-mask", &plen);
	(char *) &imask, sizeof(imask));		if (!prop \|\|
	if (plen <= 0 \|\|
	(plen % sizeof(struct linux_prom_pci_intmask)) != 0) {		(plen % sizeof(struct linux_prom_pci_intmask)) != 0) {
	printk("%s: Device %s interrupt-map-mask has bad len %d\n",		printk("%s: Device %s interrupt-map-mask has bad len %d\n",
	pbm->name, pci_name(pbus), plen);		pbm->name, pci_name(pbus), plen);
	goto no_intmap;		goto no_intmap;
	}		}
			imask = prop->value;

	orig_interrupt = interrupt;		orig_interrupt = interrupt;

	hi = pregs->phys_hi & imask.phys_hi;		hi = pregs->phys_hi & imask->phys_hi;
	mid = pregs->phys_mid & imask.phys_mid;		mid = pregs->phys_mid & imask->phys_mid;
	lo = pregs->phys_lo & imask.phys_lo;		lo = pregs->phys_lo & imask->phys_lo;
	irq = interrupt & imask.interrupt;		irq = interrupt & imask->interrupt;

	for (i = 0; i < num_imap; i++) {		for (i = 0; i < num_imap; i++) {
	if (imap[i].phys_hi == hi &&		if (imap[i].phys_hi == hi &&
	imap[i].phys_mid == mid &&		imap[i].phys_mid == mid &&
	imap[i].phys_lo == lo &&		imap[i].phys_lo == lo &&
	imap[i].interrupt == irq) {		imap[i].interrupt == irq) {
	*cnode = imap[i].cnode;		*cnode = of_find_node_by_phandle(imap[i].cnode);
	interrupt = imap[i].cinterrupt;		interrupt = imap[i].cinterrupt;
	}		}
	}		}
	@@ -638,21 +644,22 @@ static inline unsigned int pci_apply_intmap(struct pci_pbm_info *pbm,
	* all interrupt translations are complete, else we should use that node's		* all interrupt translations are complete, else we should use that node's
	* "reg" property to apply the PBM's "interrupt-{map,mask}" to the interrupt.		* "reg" property to apply the PBM's "interrupt-{map,mask}" to the interrupt.
	*/		*/
	static unsigned int __init pci_intmap_match_to_root(struct pci_pbm_info *pbm,		static struct device_node * __init
			pci_intmap_match_to_root(struct pci_pbm_info *pbm,
	struct pci_dev *pdev,		struct pci_dev *pdev,
	unsigned int *interrupt)		unsigned int *interrupt)
	{		{
	struct pci_dev *toplevel_pdev = pdev;		struct pci_dev *toplevel_pdev = pdev;
	struct pcidev_cookie *toplevel_pcp = toplevel_pdev->sysdata;		struct pcidev_cookie *toplevel_pcp = toplevel_pdev->sysdata;
	unsigned int cnode = toplevel_pcp->prom_node;		struct device_node *cnode = toplevel_pcp->prom_node;

	while (pdev->bus->number != pbm->pci_first_busno) {		while (pdev->bus->number != pbm->pci_first_busno) {
	struct pci_dev *pbus = pdev->bus->self;		struct pci_dev *pbus = pdev->bus->self;
	struct pcidev_cookie *pcp = pbus->sysdata;		struct pcidev_cookie *pcp = pbus->sysdata;
	int plen;		struct property *prop;

	plen = prom_getproplen(pcp->prom_node, "interrupt-map");		prop = of_find_property(pcp->prom_node, "interrupt-map", NULL);
	if (plen <= 0) {		if (!prop) {
	*interrupt = pci_slot_swivel(pbm, toplevel_pdev,		*interrupt = pci_slot_swivel(pbm, toplevel_pdev,
	pdev, *interrupt);		pdev, *interrupt);
	cnode = pcp->prom_node;		cnode = pcp->prom_node;
	@@ -669,7 +676,7 @@ static unsigned int __init pci_intmap_match_to_root(struct pci_pbm_info *pbm,
	}		}
	pdev = pbus;		pdev = pbus;

	if (cnode == pbm->prom_node->node)		if (cnode == pbm->prom_node)
	break;		break;
	}		}

	@@ -680,21 +687,24 @@ static int __init pci_intmap_match(struct pci_dev pdev, unsigned int interrupt
	{		{
	struct pcidev_cookie *dev_pcp = pdev->sysdata;		struct pcidev_cookie *dev_pcp = pdev->sysdata;
	struct pci_pbm_info *pbm = dev_pcp->pbm;		struct pci_pbm_info *pbm = dev_pcp->pbm;
	struct linux_prom_pci_registers reg[PROMREG_MAX];		struct linux_prom_pci_registers *reg;
			struct device_node *cnode;
			struct property *prop;
	unsigned int hi, mid, lo, irq;		unsigned int hi, mid, lo, irq;
	int i, cnode, plen;		int i, plen;

	cnode = pci_intmap_match_to_root(pbm, pdev, interrupt);		cnode = pci_intmap_match_to_root(pbm, pdev, interrupt);
	if (cnode == pbm->prom_node->node)		if (cnode == pbm->prom_node)
	goto success;		goto success;

	plen = prom_getproperty(cnode, "reg", (char *) reg, sizeof(reg));		prop = of_find_property(cnode, "reg", &plen);
	if (plen <= 0 \|\|		if (!prop \|\|
	(plen % sizeof(struct linux_prom_pci_registers)) != 0) {		(plen % sizeof(struct linux_prom_pci_registers)) != 0) {
	printk("%s: OBP node %x reg property has bad len %d\n",		printk("%s: OBP node %s reg property has bad len %d\n",
	pbm->name, cnode, plen);		pbm->name, cnode->full_name, plen);
	goto fail;		goto fail;
	}		}
			reg = prop->value;

	hi = reg[0].phys_hi & pbm->pbm_intmask->phys_hi;		hi = reg[0].phys_hi & pbm->pbm_intmask->phys_hi;
	mid = reg[0].phys_mid & pbm->pbm_intmask->phys_mid;		mid = reg[0].phys_mid & pbm->pbm_intmask->phys_mid;
	@@ -734,8 +744,8 @@ static void __init pdev_fixup_irq(struct pci_dev *pdev)
	struct pci_controller_info *p = pbm->parent;		struct pci_controller_info *p = pbm->parent;
	unsigned int portid = pbm->portid;		unsigned int portid = pbm->portid;
	unsigned int prom_irq;		unsigned int prom_irq;
	int prom_node = pcp->prom_node;		struct device_node *dp = pcp->prom_node;
	int err;		struct property *prop;

	/* If this is an empty EBUS device, sometimes OBP fails to		/* If this is an empty EBUS device, sometimes OBP fails to
	* give it a valid fully specified interrupts property.		* give it a valid fully specified interrupts property.
	@@ -746,17 +756,17 @@ static void __init pdev_fixup_irq(struct pci_dev *pdev)
	*/		*/
	if (pdev->vendor == PCI_VENDOR_ID_SUN &&		if (pdev->vendor == PCI_VENDOR_ID_SUN &&
	pdev->device == PCI_DEVICE_ID_SUN_EBUS &&		pdev->device == PCI_DEVICE_ID_SUN_EBUS &&
	!prom_getchild(prom_node)) {		!dp->child) {
	pdev->irq = 0;		pdev->irq = 0;
	return;		return;
	}		}

	err = prom_getproperty(prom_node, "interrupts",		prop = of_find_property(dp, "interrupts", NULL);
	(char *)&prom_irq, sizeof(prom_irq));		if (!prop) {
	if (err == 0 \|\| err == -1) {
	pdev->irq = 0;		pdev->irq = 0;
	return;		return;
	}		}
			prom_irq = (unsigned int ) prop->value;

	if (tlb_type != hypervisor) {		if (tlb_type != hypervisor) {
	/* Fully specified already? */		/* Fully specified already? */

arch/sparc64/kernel/pci_impl.h

+2 −1

Original line number	Original line	Diff line number	Diff line
	@@ -10,6 +10,7 @@
	#include <linux/types.h>		#include <linux/types.h>
	#include <linux/spinlock.h>		#include <linux/spinlock.h>
	#include <asm/io.h>		#include <asm/io.h>
			#include <asm/prom.h>

	extern struct pci_controller_info *pci_controller_root;		extern struct pci_controller_info *pci_controller_root;

	@@ -19,7 +20,7 @@ extern int pci_num_controllers;
	extern void pci_fixup_host_bridge_self(struct pci_bus *pbus);		extern void pci_fixup_host_bridge_self(struct pci_bus *pbus);
	extern void pci_fill_in_pbm_cookies(struct pci_bus *pbus,		extern void pci_fill_in_pbm_cookies(struct pci_bus *pbus,
	struct pci_pbm_info *pbm,		struct pci_pbm_info *pbm,
	int prom_node);		struct device_node *prom_node);
	extern void pci_record_assignments(struct pci_pbm_info *pbm,		extern void pci_record_assignments(struct pci_pbm_info *pbm,
	struct pci_bus *pbus);		struct pci_bus *pbus);
	extern void pci_assign_unassigned(struct pci_pbm_info *pbm,		extern void pci_assign_unassigned(struct pci_pbm_info *pbm,

arch/sparc64/kernel/pci_psycho.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -1104,7 +1104,7 @@ static void pbm_scan_bus(struct pci_controller_info *p,
	pci_fixup_host_bridge_self(pbm->pci_bus);		pci_fixup_host_bridge_self(pbm->pci_bus);
	pbm->pci_bus->self->sysdata = cookie;		pbm->pci_bus->self->sysdata = cookie;

	pci_fill_in_pbm_cookies(pbm->pci_bus, pbm, pbm->prom_node->node);		pci_fill_in_pbm_cookies(pbm->pci_bus, pbm, pbm->prom_node);
	pci_record_assignments(pbm, pbm->pci_bus);		pci_record_assignments(pbm, pbm->pci_bus);
	pci_assign_unassigned(pbm, pbm->pci_bus);		pci_assign_unassigned(pbm, pbm->pci_bus);
	pci_fixup_irq(pbm, pbm->pci_bus);		pci_fixup_irq(pbm, pbm->pci_bus);