Move the v3 resource allocator to v2.

Major changes:
1. Separate resource allocation into:
	A. Read Resources
	B. Avoid fixed resources (constrain limits)
	C. Allocate resources
	D. Set resources

Usage notes:
Resources which have IORESOURCE_FIXED set in the flags constrain the placement
of other resources.  All fixed resources will end up outside (above or below) 
the allocated resources.

Domains usually start with base = 0 and limit = 2^address_bits - 1.

I've added an IOAPIC to all platforms so that the old limit of 0xfec00000 is
still there for resources.  Some platforms may want to change that, but I didn't
want to break anyone's board.

Resources are allocated in a single block for memory and another for I/O.
Currently the resource allocator doesn't support holes.

Signed-off-by: Myles Watson <mylesgw@gmail.com>
Acked-by: Ronald G. Minnich <rminnich@gmail.com>
Acked-by: Patrick Georgi <patrick.georgi@coresystems.de>


git-svn-id: svn://svn.coreboot.org/coreboot/trunk@4394 2b7e53f0-3cfb-0310-b3e9-8179ed1497e1

1 files changed, 572 insertions, 258 deletions

diff --git a/src/devices/device.c b/src/devices/device.c
index 51a1203ec0..123d22a971 100644
--- a/src/devices/device.c
+++ b/src/devices/device.c
@@ -12,6 +12,7 @@
  * Copyright (C) 2005-2006 Tyan
  * (Written by Yinghai Lu <yhlu@tyan.com> for Tyan)
  * Copyright (C) 2005-2006 Stefan Reinauer <stepan@openbios.org>
+ * Copyright (C) 2009 Myles Watson <mylesgw@gmail.com>
  */
 
 /*
@@ -43,12 +44,6 @@ struct device *all_devices = &dev_root;
 /** Pointer to the last device */
 extern struct device **last_dev_p;
 
-/** The upper limit of MEM resource of the devices.
- * Reserve 20M for the system */
-#define DEVICE_MEM_HIGH 0xFEBFFFFFUL
-/** The lower limit of IO resource of the devices.
- * Reserve 4k for ISA/Legacy devices */
-#define DEVICE_IO_START 0x1000
 
 /**
  * @brief Allocate a new device structure.
@@ -71,25 +66,25 @@ device_t alloc_dev(struct bus *parent, struct device_path *path)
 
 	spin_lock(&dev_lock);
 
-	/* Find the last child of our parent */
-	for(child = parent->children; child && child->sibling; ) {
+	/* Find the last child of our parent. */
+	for (child = parent->children; child && child->sibling; /* */ ) {
 		child = child->sibling;
 	}
 
 	dev = malloc(sizeof(*dev));
-	if (dev == 0) {
+	if (dev == 0)
 		die("DEV: out of memory.\n");
-	}
+
 	memset(dev, 0, sizeof(*dev));
 	memcpy(&dev->path, path, sizeof(*path));
 
-	/* Initialize the back pointers in the link fields */
-	for(link = 0; link < MAX_LINKS; link++) {
-		dev->link[link].dev  = dev;
+	/* Initialize the back pointers in the link fields. */
+	for (link = 0; link < MAX_LINKS; link++) {
+		dev->link[link].dev = dev;
 		dev->link[link].link = link;
 	}
 
-	/* By default devices are enabled */
+	/* By default devices are enabled. */
 	dev->enabled = 1;
 
 	/* Add the new device to the list of children of the bus. */
@@ -132,64 +127,46 @@ static void read_resources(struct bus *bus)
 {
 	struct device *curdev;
 
-	printk_spew("%s read_resources bus %d link: %d\n",
-		dev_path(bus->dev), bus->secondary, bus->link);
+	printk_spew("%s %s bus %x link: %d\n", dev_path(bus->dev), __func__,
+		    bus->secondary, bus->link);
 
-	/* Walk through all of the devices and find which resources they need. */
-	for(curdev = bus->children; curdev; curdev = curdev->sibling) {
-		unsigned links;
+	/* Walk through all devices and find which resources they need. */
+	for (curdev = bus->children; curdev; curdev = curdev->sibling) {
 		int i;
-		if (curdev->have_resources) {
-			continue;
-		}
 		if (!curdev->enabled) {
 			continue;
 		}
 		if (!curdev->ops || !curdev->ops->read_resources) {
 			printk_err("%s missing read_resources\n",
-				dev_path(curdev));
+				   dev_path(curdev));
 			continue;
 		}
 		curdev->ops->read_resources(curdev);
-		curdev->have_resources = 1;
-		/* Read in subtractive resources behind the current device */
-		links = 0;
-		for(i = 0; i < curdev->resources; i++) {
-			struct resource *resource;
-			unsigned link;
-			resource = &curdev->resource[i];
-			if (!(resource->flags & IORESOURCE_SUBTRACTIVE))
-				continue;
-			link = IOINDEX_SUBTRACTIVE_LINK(resource->index);
-			if (link > MAX_LINKS) {
-				printk_err("%s subtractive index on link: %d\n",
-					dev_path(curdev), link);
-				continue;
-			}
-			if (!(links & (1 << link))) {
-				links |= (1 << link);
-				read_resources(&curdev->link[link]);
-			}
-		}
+
+		/* Read in the resources behind the current device's links. */
+		for (i = 0; i < curdev->links; i++)
+			read_resources(&curdev->link[i]);
 	}
 	printk_spew("%s read_resources bus %d link: %d done\n",
-		dev_path(bus->dev), bus->secondary, bus->link);
+		    dev_path(bus->dev), bus->secondary, bus->link);
 }
 
 struct pick_largest_state {
 	struct resource *last;
-	struct device   *result_dev;
+	struct device *result_dev;
 	struct resource *result;
 	int seen_last;
 };
 
-static void pick_largest_resource(void *gp,
-	struct device *dev, struct resource *resource)
+static void pick_largest_resource(void *gp, struct device *dev,
+				  struct resource *resource)
 {
 	struct pick_largest_state *state = gp;
 	struct resource *last;
+
 	last = state->last;
-	/* Be certain to pick the successor to last */
+
+	/* Be certain to pick the successor to last. */
 	if (resource == last) {
 		state->seen_last = 1;
 		return;
@@ -206,21 +183,22 @@ static void pick_largest_resource(void *gp,
 	if (!state->result ||
 	    (state->result->align < resource->align) ||
 	    ((state->result->align == resource->align) &&
-	     (state->result->size < resource->size)))
-	{
+	     (state->result->size < resource->size))) {
 		state->result_dev = dev;
 		state->result = resource;
 	}
 }
 
-static struct device *largest_resource(struct bus *bus, struct resource **result_res,
-	unsigned long type_mask, unsigned long type)
+static struct device *largest_resource(struct bus *bus,
+				       struct resource **result_res,
+				       unsigned long type_mask,
+				       unsigned long type)
 {
 	struct pick_largest_state state;
 
 	state.last = *result_res;
-	state.result_dev = 0;
-	state.result = 0;
+	state.result_dev = NULL;
+	state.result = NULL;
 	state.seen_last = 0;
 
 	search_bus_resources(bus, type_mask, type, pick_largest_resource,
@@ -233,144 +211,136 @@ static struct device *largest_resource(struct bus *bus, struct resource **result
 /* Compute allocate resources is the guts of the resource allocator.
  *
  * The problem.
- *  - Allocate resources locations for every device.
+ *  - Allocate resource locations for every device.
  *  - Don't overlap, and follow the rules of bridges.
  *  - Don't overlap with resources in fixed locations.
  *  - Be efficient so we don't have ugly strategies.
  *
  * The strategy.
  * - Devices that have fixed addresses are the minority so don't
- *   worry about them too much.  Instead only use part of the address
- *   space for devices with programmable addresses.  This easily handles
+ *   worry about them too much. Instead only use part of the address
+ *   space for devices with programmable addresses. This easily handles
  *   everything except bridges.
  *
- * - PCI devices are required to have thier sizes and their alignments
- *   equal.  In this case an optimal solution to the packing problem
- *   exists.  Allocate all devices from highest alignment to least
- *   alignment or vice versa.  Use this.
+ * - PCI devices are required to have their sizes and their alignments
+ *   equal. In this case an optimal solution to the packing problem
+ *   exists. Allocate all devices from highest alignment to least
+ *   alignment or vice versa. Use this.
  *
- * - So we can handle more than PCI run two allocation passes on
- *   bridges.  The first to see how large the resources are behind
- *   the bridge, and what their alignment requirements are.  The
- *   second to assign a safe address to the devices behind the
- *   bridge.  This allows me to treat a bridge as just a device with
- *   a couple of resources, and not need to special case it in the
- *   allocator.  Also this allows handling of other types of bridges.
+ * - So we can handle more than PCI run two allocation passes on bridges. The
+ *   first to see how large the resources are behind the bridge, and what
+ *   their alignment requirements are. The second to assign a safe address to
+ *   the devices behind the bridge. This allows us to treat a bridge as just
+ *   a device with a couple of resources, and not need to special case it in
+ *   the allocator. Also this allows handling of other types of bridges.
  *
  */
-
-void compute_allocate_resource(
-	struct bus *bus,
-	struct resource *bridge,
-	unsigned long type_mask,
-	unsigned long type)
+void compute_resources(struct bus *bus, struct resource *bridge,
+		       unsigned long type_mask, unsigned long type)
 {
 	struct device *dev;
 	struct resource *resource;
 	resource_t base;
-	unsigned long align, min_align;
-	min_align = 0;
-	base = bridge->base;
+	base = round(bridge->base, bridge->align);
 
-	printk_spew("%s compute_allocate_resource %s: base: %08Lx size: %08Lx align: %d gran: %d\n",
-		dev_path(bus->dev),
-		(bridge->flags & IORESOURCE_IO)? "io":
-		(bridge->flags & IORESOURCE_PREFETCH)? "prefmem" : "mem",
-		base, bridge->size, bridge->align, bridge->gran);
+	printk_spew( "%s %s_%s: base: %llx size: %llx align: %d gran: %d limit: %llx\n",
+	       dev_path(bus->dev), __func__,
+	       (type & IORESOURCE_IO) ? "io" : (type & IORESOURCE_PREFETCH) ?
+	       "prefmem" : "mem",
+	       base, bridge->size, bridge->align, bridge->gran, bridge->limit);
 
-	/* We want different minimum alignments for different kinds of
-	 * resources.  These minimums are not device type specific
-	 * but resource type specific.
-	 */
-	if (bridge->flags & IORESOURCE_IO) {
-		min_align = log2(DEVICE_IO_ALIGN);
-	}
-	if (bridge->flags & IORESOURCE_MEM) {
-		min_align = log2(DEVICE_MEM_ALIGN);
-	}
+	/* For each child which is a bridge, compute_resource_needs. */
+	for (dev = bus->children; dev; dev = dev->sibling) {
+		unsigned i;
+		struct resource *child_bridge;
 
-	/* Make certain I have read in all of the resources */
-	read_resources(bus);
+		if (!dev->links)
+			continue;
 
-	/* Remember I haven't found anything yet. */
-	resource = 0;
+		/* Find the resources with matching type flags. */
+		for (i = 0; i < dev->resources; i++) {
+			unsigned link;
+			child_bridge = &dev->resource[i];
 
-	/* Walk through all the devices on the current bus and
-	 * compute the addresses.
-	 */
-	while((dev = largest_resource(bus, &resource, type_mask, type))) {
-		resource_t size;
-		/* Do NOT I repeat do not ignore resources which have zero size.
-		 * If they need to be ignored dev->read_resources should not even
-		 * return them.   Some resources must be set even when they have
-		 * no size.  PCI bridge resources are a good example of this.
-		 */
-		/* Make certain we are dealing with a good minimum size */
-		size = resource->size;
-		align = resource->align;
-		if (align < min_align) {
-			align = min_align;
-		}
+			if (!(child_bridge->flags & IORESOURCE_BRIDGE) ||
+			    (child_bridge->flags & type_mask) != type)
+				continue;
 
-		/* Propagate the resource alignment to the bridge register  */
-		if (align > bridge->align) {
-			bridge->align = align;
+			/* Split prefetchable memory if combined.  Many domains
+			 * use the same address space for prefetchable memory
+			 * and non-prefetchable memory.  Bridges below them
+			 * need it separated.  Add the PREFETCH flag to the
+			 * type_mask and type.
+			 */
+			link = IOINDEX_LINK(child_bridge->index);
+			compute_resources(&dev->link[link], child_bridge,
+					  type_mask | IORESOURCE_PREFETCH,
+					  type | (child_bridge->flags &
+						  IORESOURCE_PREFETCH));
 		}
+	}
+
+	/* Remember we haven't found anything yet. */
+	resource = NULL;
+
+	/* Walk through all the resources on the current bus and compute the
+	 * amount of address space taken by them.  Take granularity and
+	 * alignment into account.
+	 */
+	while ((dev = largest_resource(bus, &resource, type_mask, type))) {
 
-		if (resource->flags & IORESOURCE_FIXED) {
+		/* Size 0 resources can be skipped. */
+		if (!resource->size) {
 			continue;
 		}
 
-		/* Propogate the resource limit to the bridge register */
+		/* Propagate the resource alignment to the bridge resource. */
+		if (resource->align > bridge->align) {
+			bridge->align = resource->align;
+		}
+
+		/* Propagate the resource limit to the bridge register. */
 		if (bridge->limit > resource->limit) {
 			bridge->limit = resource->limit;
 		}
-#warning This heuristic should be replaced by real devices with fixed resources.
-		/* Artificially deny limits between DEVICE_MEM_HIGH and 0xffffffff */
-		if ((bridge->limit > DEVICE_MEM_HIGH) && (bridge->limit <= 0xffffffff)) {
-			bridge->limit = DEVICE_MEM_HIGH;
+
+		/* Warn if it looks like APICs aren't declared. */
+		if ((resource->limit == 0xffffffff) &&
+		    (resource->flags & IORESOURCE_ASSIGNED)) {
+			printk_err("Resource limit looks wrong! (no APIC?)\n");
+			printk_err("%s %02lx limit %08Lx\n", dev_path(dev),
+			           resource->index, resource->limit);
 		}
 
 		if (resource->flags & IORESOURCE_IO) {
-			/* Don't allow potential aliases over the
-			 * legacy pci expansion card addresses.
-			 * The legacy pci decodes only 10 bits,
-			 * uses 100h - 3ffh. Therefor, only 0 - ff
-			 * can be used out of each 400h block of io
-			 * space.
+			/* Don't allow potential aliases over the legacy PCI
+			 * expansion card addresses. The legacy PCI decodes
+			 * only 10 bits, uses 0x100 - 0x3ff. Therefore, only
+			 * 0x00 - 0xff can be used out of each 0x400 block of
+			 * I/O space.
 			 */
 			if ((base & 0x300) != 0) {
 				base = (base & ~0x3ff) + 0x400;
 			}
-			/* Don't allow allocations in the VGA IO range.
+			/* Don't allow allocations in the VGA I/O range.
 			 * PCI has special cases for that.
 			 */
 			else if ((base >= 0x3b0) && (base <= 0x3df)) {
 				base = 0x3e0;
 			}
 		}
-		if (((round(base, align) + size) -1) <= resource->limit) {
-			/* base must be aligned to size */
-			base = round(base, align);
-			resource->base = base;
-			resource->flags |= IORESOURCE_ASSIGNED;
-			resource->flags &= ~IORESOURCE_STORED;
-			base += size;
-
-			printk_spew("%s %02lx *  [0x%08Lx - 0x%08Lx] %s\n",
-				dev_path(dev),
-				resource->index,
-				resource->base,
-				resource->base + resource->size - 1,
-				(resource->flags & IORESOURCE_IO)? "io":
-				(resource->flags & IORESOURCE_PREFETCH)? "prefmem": "mem");
-		}
-#if CONFIG_PCIE_CONFIGSPACE_HOLE
-#warning Handle PCIe hole differently...
-		if (base >= 0xf0000000 && base < 0xf4000000) {
-			base = 0xf4000000;
-		}
-#endif
+		/* Base must be aligned. */
+		base = round(base, resource->align);
+		resource->base = base;
+		base += resource->size;
+
+		printk_spew("%s %02lx *  [0x%llx - 0x%llx] %s\n",
+			    dev_path(dev), resource->index,
+			    resource->base,
+			    resource->base + resource->size - 1,
+			    (resource->flags & IORESOURCE_IO) ? "io" :
+			    (resource->flags & IORESOURCE_PREFETCH) ?
+			     "prefmem" : "mem");
 	}
 	/* A pci bridge resource does not need to be a power
 	 * of two size, but it does have a minimum granularity.
@@ -378,13 +348,317 @@ void compute_allocate_resource(
 	 * know not to place something else at an address postitively
 	 * decoded by the bridge.
 	 */
-	bridge->size = round(base, bridge->gran) - bridge->base;
+	bridge->size = round(base, bridge->gran) -
+		       round(bridge->base, bridge->align);
+
+	printk_spew("%s %s_%s: base: %llx size: %llx align: %d gran: %d limit: %llx done\n",
+		    dev_path(bus->dev), __func__,
+		    (bridge->flags & IORESOURCE_IO) ? "io" :
+		     (bridge->flags & IORESOURCE_PREFETCH) ?  "prefmem" : "mem",
+		    base, bridge->size, bridge->align, bridge->gran, bridge->limit);
+}
+
+/**
+ * This function is the second part of the resource allocator.
+ *
+ * The problem.
+ *  - Allocate resource locations for every device.
+ *  - Don't overlap, and follow the rules of bridges.
+ *  - Don't overlap with resources in fixed locations.
+ *  - Be efficient so we don't have ugly strategies.
+ *
+ * The strategy.
+ * - Devices that have fixed addresses are the minority so don't
+ *   worry about them too much. Instead only use part of the address
+ *   space for devices with programmable addresses. This easily handles
+ *   everything except bridges.
+ *
+ * - PCI devices are required to have their sizes and their alignments
+ *   equal. In this case an optimal solution to the packing problem
+ *   exists. Allocate all devices from highest alignment to least
+ *   alignment or vice versa. Use this.
+ *
+ * - So we can handle more than PCI run two allocation passes on bridges. The
+ *   first to see how large the resources are behind the bridge, and what
+ *   their alignment requirements are. The second to assign a safe address to
+ *   the devices behind the bridge. This allows us to treat a bridge as just
+ *   a device with a couple of resources, and not need to special case it in
+ *   the allocator. Also this allows handling of other types of bridges.
+ *
+ * - This function assigns the resources a value.
+ *
+ * @param bus The bus we are traversing.
+ * @param bridge The bridge resource which must contain the bus' resources.
+ * @param type_mask This value gets anded with the resource type.
+ * @param type This value must match the result of the and.
+ */
+void allocate_resources(struct bus *bus, struct resource *bridge,
+			unsigned long type_mask, unsigned long type)
+{
+	struct device *dev;
+	struct resource *resource;
+	resource_t base;
+	base = bridge->base;
+
+	printk_spew("%s %s_%s: base:%llx size:%llx align:%d gran:%d limit:%llx\n",
+	       dev_path(bus->dev), __func__,
+	       (type & IORESOURCE_IO) ? "io" : (type & IORESOURCE_PREFETCH) ?
+	       "prefmem" : "mem",
+	       base, bridge->size, bridge->align, bridge->gran, bridge->limit);
+
+	/* Remember we haven't found anything yet. */
+	resource = NULL;
+
+	/* Walk through all the resources on the current bus and allocate them
+	 * address space.
+	 */
+	while ((dev = largest_resource(bus, &resource, type_mask, type))) {
+
+		/* Propagate the bridge limit to the resource register. */
+		if (resource->limit > bridge->limit) {
+			resource->limit = bridge->limit;
+		}
+
+		/* Size 0 resources can be skipped. */
+		if (!resource->size) {
+			/* Set the base to limit so it doesn't confuse tolm. */
+			resource->base = resource->limit;
+			resource->flags |= IORESOURCE_ASSIGNED;
+			continue;
+		}
+
+		if (resource->flags & IORESOURCE_IO) {
+			/* Don't allow potential aliases over the legacy PCI
+			 * expansion card addresses. The legacy PCI decodes
+			 * only 10 bits, uses 0x100 - 0x3ff. Therefore, only
+			 * 0x00 - 0xff can be used out of each 0x400 block of
+			 * I/O space.
+			 */
+			if ((base & 0x300) != 0) {
+				base = (base & ~0x3ff) + 0x400;
+			}
+			/* Don't allow allocations in the VGA I/O range.
+			 * PCI has special cases for that.
+			 */
+			else if ((base >= 0x3b0) && (base <= 0x3df)) {
+				base = 0x3e0;
+			}
+		}
+
+		if ((round(base, resource->align) + resource->size - 1) <=
+		    resource->limit) {
+			/* Base must be aligned. */
+			base = round(base, resource->align);
+			resource->base = base;
+			resource->flags |= IORESOURCE_ASSIGNED;
+			resource->flags &= ~IORESOURCE_STORED;
+			base += resource->size;
+		} else {
+			printk_err("!! Resource didn't fit !!\n");
+			printk_err("   aligned base %llx size %llx limit %llx\n",
+			       round(base, resource->align), resource->size,
+			       resource->limit);
+			printk_err("   %llx needs to be <= %llx (limit)\n",
+			       (round(base, resource->align) +
+				resource->size) - 1, resource->limit);
+			printk_err("   %s%s %02lx *  [0x%llx - 0x%llx] %s\n",
+			       (resource->
+				flags & IORESOURCE_ASSIGNED) ? "Assigned: " :
+			       "", dev_path(dev), resource->index,
+			       resource->base,
+			       resource->base + resource->size - 1,
+			       (resource->
+				flags & IORESOURCE_IO) ? "io" : (resource->
+								 flags &
+								 IORESOURCE_PREFETCH)
+			       ? "prefmem" : "mem");
+		}
+
+		printk_spew("%s%s %02lx *  [0x%llx - 0x%llx] %s\n",
+		       (resource->flags & IORESOURCE_ASSIGNED) ? "Assigned: "
+		       : "",
+		       dev_path(dev), resource->index, resource->base,
+		       resource->size ? resource->base + resource->size - 1 :
+		       resource->base,
+		       (resource->flags & IORESOURCE_IO) ? "io" :
+		       (resource->flags & IORESOURCE_PREFETCH) ? "prefmem" :
+		       "mem");
+	}
+	/* A PCI bridge resource does not need to be a power of two size, but
+	 * it does have a minimum granularity. Round the size up to that
+	 * minimum granularity so we know not to place something else at an
+	 * address positively decoded by the bridge.
+	 */
+
+	bridge->flags |= IORESOURCE_ASSIGNED;
+
+	printk_spew("%s %s_%s: next_base: %llx size: %llx align: %d gran: %d done\n",
+	       dev_path(bus->dev), __func__,
+	       (type & IORESOURCE_IO) ? "io" : (type & IORESOURCE_PREFETCH) ?
+	       "prefmem" : "mem",
+	       base, bridge->size, bridge->align, bridge->gran);
+
+	/* For each child which is a bridge, allocate_resources. */
+	for (dev = bus->children; dev; dev = dev->sibling) {
+		unsigned i;
+		struct resource *child_bridge;
 
-	printk_spew("%s compute_allocate_resource %s: base: %08Lx size: %08Lx align: %d gran: %d done\n",
-		    dev_path(bus->dev),
-		    (bridge->flags & IORESOURCE_IO)? "io":
-		     (bridge->flags & IORESOURCE_PREFETCH)? "prefmem" : "mem",
-		    base, bridge->size, bridge->align, bridge->gran);
+		if (!dev->links)
+			continue;
+
+		/* Find the resources with matching type flags. */
+		for (i = 0; i < dev->resources; i++) {
+			unsigned link;
+			child_bridge = &dev->resource[i];
+
+			if (!(child_bridge->flags & IORESOURCE_BRIDGE) ||
+			    (child_bridge->flags & type_mask) != type)
+				continue;
+
+			/* Split prefetchable memory if combined.  Many domains
+			 * use the same address space for prefetchable memory
+			 * and non-prefetchable memory.  Bridges below them
+			 * need it separated.  Add the PREFETCH flag to the
+			 * type_mask and type.
+			 */
+			link = IOINDEX_LINK(child_bridge->index);
+			allocate_resources(&dev->link[link], child_bridge,
+					   type_mask | IORESOURCE_PREFETCH,
+					   type | (child_bridge->flags &
+						   IORESOURCE_PREFETCH));
+		}
+	}
+}
+
+#if CONFIG_PCI_64BIT_PREF_MEM == 1
+	#define MEM_MASK (IORESOURCE_PREFETCH | IORESOURCE_MEM)
+#else
+	#define MEM_MASK (IORESOURCE_MEM)
+#endif
+#define IO_MASK (IORESOURCE_IO)
+#define PREF_TYPE (IORESOURCE_PREFETCH | IORESOURCE_MEM)
+#define MEM_TYPE (IORESOURCE_MEM)
+#define IO_TYPE (IORESOURCE_IO)
+
+struct constraints {
+	struct resource pref, io, mem;
+};
+
+static void constrain_resources(struct device *dev, struct constraints* limits)
+{
+	struct device *child;
+	struct resource *res;
+	struct resource *lim;
+	int i;
+
+	printk_spew("%s: %s\n", __func__, dev_path(dev));
+
+	/* Constrain limits based on the fixed resources of this device. */
+	for (i = 0; i < dev->resources; i++) {
+		res = &dev->resource[i];
+		if (!(res->flags & IORESOURCE_FIXED))
+			continue;
+
+		/* PREFETCH, MEM, or I/O - skip any others. */
+		if ((res->flags & MEM_MASK) == PREF_TYPE)
+			lim = &limits->pref;
+		else if ((res->flags & MEM_MASK) == MEM_TYPE)
+			lim = &limits->mem;
+		else if ((res->flags & IO_MASK) == IO_TYPE)
+			lim = &limits->io;
+		else
+			continue;
+
+		/* Is it already outside the limits? */
+		if (res->size && (((res->base + res->size -1) < lim->base) ||
+				  (res->base > lim->limit)))
+			continue;
+
+		/* Choose to be above or below fixed resources.  This
+		 * check is signed so that "negative" amounts of space
+		 * are handled correctly.
+		 */
+		if ((signed long long)(lim->limit - (res->base + res->size -1)) >
+		    (signed long long)(res->base - lim->base))
+			lim->base = res->base + res->size;
+		else
+			lim->limit = res->base -1;
+	}
+
+	/* Descend into every enabled child and look for fixed resources. */
+	for (i = 0; i < dev->links; i++)
+		for (child = dev->link[i].children; child;
+		     child = child->sibling)
+			if (child->enabled)
+				constrain_resources(child, limits);
+}
+
+static void avoid_fixed_resources(struct device *dev)
+{
+	struct constraints limits;
+	struct resource *res;
+	int i;
+
+	printk_spew("%s: %s\n", __func__, dev_path(dev));
+	/* Initialize constraints to maximum size. */
+
+	limits.pref.base = 0;
+	limits.pref.limit = 0xffffffffffffffffULL;
+	limits.io.base = 0;
+	limits.io.limit = 0xffffffffffffffffULL;
+	limits.mem.base = 0;
+	limits.mem.limit = 0xffffffffffffffffULL;
+
+	/* Constrain the limits to dev's initial resources. */
+	for (i = 0; i < dev->resources; i++) {
+		res = &dev->resource[i];
+		if ((res->flags & IORESOURCE_FIXED))
+			continue;
+		printk_spew("%s:@%s %02lx limit %08Lx\n", __func__,
+			     dev_path(dev), res->index, res->limit);
+		if ((res->flags & MEM_MASK) == PREF_TYPE &&
+		    (res->limit < limits.pref.limit))
+			limits.pref.limit = res->limit;
+		if ((res->flags & MEM_MASK) == MEM_TYPE &&
+		    (res->limit < limits.mem.limit))
+			limits.mem.limit = res->limit;
+		if ((res->flags & IO_MASK) == IO_TYPE &&
+		    (res->limit < limits.io.limit))
+			limits.io.limit = res->limit;
+	}
+
+	/* Look through the tree for fixed resources and update the limits. */
+	constrain_resources(dev, &limits);
+
+	/* Update dev's resources with new limits. */
+	for (i = 0; i < dev->resources; i++) {
+		struct resource *lim;
+		res = &dev->resource[i];
+
+		if ((res->flags & IORESOURCE_FIXED))
+			continue;
+
+		/* PREFETCH, MEM, or I/O - skip any others. */
+		if ((res->flags & MEM_MASK) == PREF_TYPE)
+			lim = &limits.pref;
+		else if ((res->flags & MEM_MASK) == MEM_TYPE)
+			lim = &limits.mem;
+		else if ((res->flags & IO_MASK) == IO_TYPE)
+			lim = &limits.io;
+		else
+			continue;
+
+		printk_spew("%s2: %s@%02lx limit %08Lx\n", __func__,
+			     dev_path(dev), res->index, res->limit);
+		printk_spew("\tlim->base %08Lx lim->limit %08Lx\n",
+			     lim->base, lim->limit);
+
+		/* Is the resource outside the limits? */
+		if (lim->base > res->base)
+			res->base = lim->base;
+		if (res->limit > lim->limit)
+			res->limit = lim->limit;
+	}
 }
 
 #if CONFIG_CONSOLE_VGA == 1
@@ -392,9 +666,9 @@ device_t vga_pri = 0;
 static void allocate_vga_resource(void)
 {
 #warning "FIXME modify allocate_vga_resource so it is less pci centric!"
-#warning "This function knows to much about PCI stuff, it should be just a ietrator/visitor."
+#warning "This function knows too much about PCI stuff, it should be just a iterator/visitor."
 
-	/* FIXME handle the VGA pallette snooping */
+	/* FIXME: Handle the VGA palette snooping. */
 	struct device *dev, *vga, *vga_onboard, *vga_first, *vga_last;
 	struct bus *bus;
 	bus = 0;
@@ -402,66 +676,63 @@ static void allocate_vga_resource(void)
 	vga_onboard = 0;
 	vga_first = 0;
 	vga_last = 0;
-	for(dev = all_devices; dev; dev = dev->next) {
-		if (!dev->enabled) continue;
+	for (dev = all_devices; dev; dev = dev->next) {
+		if (!dev->enabled)
+			continue;
 		if (((dev->class >> 16) == PCI_BASE_CLASS_DISPLAY) &&
-			((dev->class >> 8) != PCI_CLASS_DISPLAY_OTHER))
-		{
-                        if (!vga_first) {
-                                if (dev->on_mainboard) {
-                                        vga_onboard = dev;
-                                } else {
-                                        vga_first = dev;
-                                }
-                        } else {
-                                if (dev->on_mainboard) {
-                                        vga_onboard = dev;
-                                } else {
-                                        vga_last = dev;
-                                }
-                        }
-
-			/* It isn't safe to enable other VGA cards */
+		    ((dev->class >> 8) != PCI_CLASS_DISPLAY_OTHER)) {
+			if (!vga_first) {
+				if (dev->on_mainboard) {
+					vga_onboard = dev;
+				} else {
+					vga_first = dev;
+				}
+			} else {
+				if (dev->on_mainboard) {
+					vga_onboard = dev;
+				} else {
+					vga_last = dev;
+				}
+			}
+
+			/* It isn't safe to enable other VGA cards. */
 			dev->command &= ~(PCI_COMMAND_MEMORY | PCI_COMMAND_IO);
 		}
 	}
 
-        vga = vga_last;
-
-        if(!vga) {
-                vga = vga_first;
-        }
+	vga = vga_last;
 
+	if (!vga) {
+		vga = vga_first;
+	}
 #if CONFIG_CONSOLE_VGA_ONBOARD_AT_FIRST == 1
-        if (vga_onboard) // will use on board vga as pri
+	if (vga_onboard)	// Will use on board VGA as pri.
 #else
-        if (!vga) // will use last add on adapter as pri
+	if (!vga)		// Will use last add on adapter as pri.
 #endif
-        {
-                vga = vga_onboard;
-        }
-
+	{
+		vga = vga_onboard;
+	}
 
 	if (vga) {
-		/* vga is first add on card or the only onboard vga */
+		/* VGA is first add on card or the only onboard VGA. */
 		printk_debug("Allocating VGA resource %s\n", dev_path(vga));
-		/* All legacy VGA cards have MEM & I/O space registers */
+		/* All legacy VGA cards have MEM & I/O space registers. */
 		vga->command |= (PCI_COMMAND_MEMORY | PCI_COMMAND_IO);
 		vga_pri = vga;
 		bus = vga->bus;
 	}
-	/* Now walk up the bridges setting the VGA enable */
-	while(bus) {
+	/* Now walk up the bridges setting the VGA enable. */
+	while (bus) {
 		printk_debug("Setting PCI_BRIDGE_CTL_VGA for bridge %s\n",
 			     dev_path(bus->dev));
 		bus->bridge_ctrl |= PCI_BRIDGE_CTL_VGA;
-		bus = (bus == bus->dev->bus)? 0 : bus->dev->bus;
+		bus = (bus == bus->dev->bus) ? 0 : bus->dev->bus;
 	}
 }
 
 #endif
 
-
 /**
  * @brief  Assign the computed resources to the devices on the bus.
  *
@@ -480,21 +751,21 @@ void assign_resources(struct bus *bus)
 	struct device *curdev;
 
 	printk_spew("%s assign_resources, bus %d link: %d\n",
-		dev_path(bus->dev), bus->secondary, bus->link);
+		    dev_path(bus->dev), bus->secondary, bus->link);
 
-	for(curdev = bus->children; curdev; curdev = curdev->sibling) {
+	for (curdev = bus->children; curdev; curdev = curdev->sibling) {
 		if (!curdev->enabled || !curdev->resources) {
 			continue;
 		}
 		if (!curdev->ops || !curdev->ops->set_resources) {
 			printk_err("%s missing set_resources\n",
-				dev_path(curdev));
+				   dev_path(curdev));
 			continue;
 		}
 		curdev->ops->set_resources(curdev);
 	}
 	printk_spew("%s assign_resources, bus %d link: %d\n",
-		dev_path(bus->dev), bus->secondary, bus->link);
+		    dev_path(bus->dev), bus->secondary, bus->link);
 }
 
 /**
@@ -539,8 +810,7 @@ void enable_resources(struct device *dev)
  */
 int reset_bus(struct bus *bus)
 {
-	if (bus && bus->dev && bus->dev->ops && bus->dev->ops->reset_bus)
-	{
+	if (bus && bus->dev && bus->dev->ops && bus->dev->ops->reset_bus) {
 		bus->dev->ops->reset_bus(bus);
 		bus->reset_needed = 0;
 		return 1;
@@ -551,37 +821,34 @@ int reset_bus(struct bus *bus)
 /**
  * @brief Scan for devices on a bus.
  *
- * If there are bridges on the bus, recursively scan the buses behind the bridges.
- * If the setting up and tuning of the bus causes a reset to be required,
- * reset the bus and scan it again.
+ * If there are bridges on the bus, recursively scan the buses behind the
+ * bridges. If the setting up and tuning of the bus causes a reset to be
+ * required, reset the bus and scan it again.
  *
- * @param bus pointer to the bus device
- * @param max current bus number
- *
- * @return The maximum bus number found, after scanning all subordinate busses
+ * @param busdev Pointer to the bus device.
+ * @param max Current bus number.
+ * @return The maximum bus number found, after scanning all subordinate buses.
  */
-unsigned int scan_bus(device_t bus, unsigned int max)
+unsigned int scan_bus(struct device *busdev, unsigned int max)
 {
 	unsigned int new_max;
 	int do_scan_bus;
-	if (	!bus ||
-		!bus->enabled ||
-		!bus->ops ||
-		!bus->ops->scan_bus)
-	{
+	if (!busdev || !busdev->enabled || !busdev->ops ||
+	    !busdev->ops->scan_bus) {
 		return max;
 	}
+
 	do_scan_bus = 1;
-	while(do_scan_bus) {
+	while (do_scan_bus) {
 		int link;
-		new_max = bus->ops->scan_bus(bus, max);
+		new_max = busdev->ops->scan_bus(busdev, max);
 		do_scan_bus = 0;
-		for(link = 0; link < bus->links; link++) {
-			if (bus->link[link].reset_needed) {
-				if (reset_bus(&bus->link[link])) {
+		for (link = 0; link < busdev->links; link++) {
+			if (busdev->link[link].reset_needed) {
+				if (reset_bus(&busdev->link[link])) {
 					do_scan_bus = 1;
 				} else {
-					bus->bus->reset_needed = 1;
+					busdev->bus->reset_needed = 1;
 				}
 			}
 		}
@@ -589,7 +856,6 @@ unsigned int scan_bus(device_t bus, unsigned int max)
 	return new_max;
 }
 
-
 /**
  * @brief Determine the existence of devices and extend the device tree.
  *
@@ -619,7 +885,7 @@ void dev_enumerate(void)
 	printk_info("Enumerating buses...\n");
 	root = &dev_root;
 
-	show_all_devs(BIOS_DEBUG, "Before Phase 3.");
+	show_all_devs(BIOS_DEBUG, "Before Device Enumeration.");
 	printk_debug("Compare with tree...\n");
 
 	show_devs_tree(root, BIOS_DEBUG, 0, 0);
@@ -643,66 +909,115 @@ void dev_enumerate(void)
  * requried by each device. In the second pass, the resources ranges are
  * relocated to their final position and stored to the hardware.
  *
- * I/O resources start at DEVICE_IO_START and grow upward. MEM resources start
- * at DEVICE_MEM_HIGH and grow downward.
+ * I/O resources grow upward. MEM resources grow downward.
  *
  * Since the assignment is hierarchical we set the values into the dev_root
  * struct.
  */
 void dev_configure(void)
 {
-	struct resource *io, *mem;
+	struct resource *res;
 	struct device *root;
+	struct device *child;
+	int i;
 
 	printk_info("Allocating resources...\n");
 
 	root = &dev_root;
 
-	print_resource_tree(root, BIOS_DEBUG, "Original.");
+	/* Each domain should create resources which contain the entire address
+	 * space for IO, MEM, and PREFMEM resources in the domain. The
+	 * allocation of device resources will be done from this address space.
+	 */
 
-	if (!root->ops || !root->ops->read_resources) {
-		printk_err("dev_root missing read_resources\n");
-		return;
-	}
-	if (!root->ops || !root->ops->set_resources) {
-		printk_err("dev_root missing set_resources\n");
-		return;
-	}
+	/* Read the resources for the entire tree. */
 
 	printk_info("Reading resources...\n");
-	root->ops->read_resources(root);
+	read_resources(&root->link[0]);
 	printk_info("Done reading resources.\n");
 
 	print_resource_tree(root, BIOS_DEBUG, "After reading.");
 
-	/* Get the resources */
-	io  = &root->resource[0];
-	mem = &root->resource[1];
-	/* Make certain the io devices are allocated somewhere safe. */
-	io->base = DEVICE_IO_START;
-	io->flags |= IORESOURCE_ASSIGNED;
-	io->flags &= ~IORESOURCE_STORED;
-	/* Now reallocate the pci resources memory with the
-	 * highest addresses I can manage.
+	/* Compute resources for all domains. */
+	for (child = root->link[0].children; child; child = child->sibling) {
+		if (!(child->path.type == DEVICE_PATH_PCI_DOMAIN))
+			continue;
+		for (i = 0; i < child->resources; i++) {
+			res = &child->resource[i];
+			if (res->flags & IORESOURCE_FIXED)
+				continue;
+			if (res->flags & IORESOURCE_PREFETCH) {
+				compute_resources(&child->link[0],
+					       res, MEM_MASK, PREF_TYPE);
+				continue;
+			}
+			if (res->flags & IORESOURCE_MEM) {
+				compute_resources(&child->link[0],
+					       res, MEM_MASK, MEM_TYPE);
+				continue;
+			}
+			if (res->flags & IORESOURCE_IO) {
+				compute_resources(&child->link[0],
+					       res, IO_MASK, IO_TYPE);
+				continue;
+			}
+		}
+	}
+
+	/* For all domains. */
+	for (child = root->link[0].children; child; child=child->sibling)
+		if (child->path.type == DEVICE_PATH_PCI_DOMAIN)
+			avoid_fixed_resources(child);
+
+	/* Now we need to adjust the resources. MEM resources need to start at
+	 * the highest address managable.
 	 */
-	mem->base = resource_max(&root->resource[1]);
-	mem->flags |= IORESOURCE_ASSIGNED;
-	mem->flags &= ~IORESOURCE_STORED;
+	for (child = root->link[0].children; child; child = child->sibling) {
+		if (child->path.type != DEVICE_PATH_PCI_DOMAIN)
+			continue;
+		for (i = 0; i < child->resources; i++) {
+			res = &child->resource[i];
+			if (!(res->flags & IORESOURCE_MEM) ||
+			    res->flags & IORESOURCE_FIXED)
+				continue;
+			res->base = resource_max(res);
+		}
+	}
 
 #if CONFIG_CONSOLE_VGA == 1
-	/* Allocate the VGA I/O resource.. */
+	/* Allocate the VGA I/O resource. */
 	allocate_vga_resource();
 	print_resource_tree(root, BIOS_DEBUG, "After VGA.");
 #endif
 
 	/* Store the computed resource allocations into device registers ... */
 	printk_info("Setting resources...\n");
-	root->ops->set_resources(root);
+	for (child = root->link[0].children; child; child = child->sibling) {
+		if (!(child->path.type == DEVICE_PATH_PCI_DOMAIN))
+			continue;
+		for (i = 0; i < child->resources; i++) {
+			res = &child->resource[i];
+			if (res->flags & IORESOURCE_FIXED)
+				continue;
+			if (res->flags & IORESOURCE_PREFETCH) {
+				allocate_resources(&child->link[0],
+					       res, MEM_MASK, PREF_TYPE);
+				continue;
+			}
+			if (res->flags & IORESOURCE_MEM) {
+				allocate_resources(&child->link[0],
+					       res, MEM_MASK, MEM_TYPE);
+				continue;
+			}
+			if (res->flags & IORESOURCE_IO) {
+				allocate_resources(&child->link[0],
+					       res, IO_MASK, IO_TYPE);
+				continue;
+			}
+		}
+	}
+	assign_resources(&root->link[0]);
 	printk_info("Done setting resources.\n");
-#if 0
-	mem->flags |= IORESOURCE_STORED;
-	report_resource_stored(root, mem, "");
-#endif
 	print_resource_tree(root, BIOS_DEBUG, "After assigning values.");
 
 	printk_info("Done allocating resources.\n");
@@ -736,13 +1051,13 @@ void dev_initialize(void)
 	struct device *dev;
 
 	printk_info("Initializing devices...\n");
-	for(dev = all_devices; dev; dev = dev->next) {
+	for (dev = all_devices; dev; dev = dev->next) {
 		if (dev->enabled && !dev->initialized &&
-			dev->ops && dev->ops->init)
-		{
+		    dev->ops && dev->ops->init) {
 			if (dev->path.type == DEVICE_PATH_I2C) {
- 				printk_debug("smbus: %s[%d]->",
-					dev_path(dev->bus->dev), dev->bus->link);
+				printk_debug("smbus: %s[%d]->",
+					     dev_path(dev->bus->dev),
+					     dev->bus->link);
 			}
 			printk_debug("%s init\n", dev_path(dev));
 			dev->initialized = 1;
@@ -752,4 +1067,3 @@ void dev_initialize(void)
 	printk_info("Devices initialized\n");
 	show_all_devs(BIOS_DEBUG, "After init.");
 }
-