X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fdevices%2Fdevice.c;h=0e9c39e2031d7fe77c5fc4fa8b42d23a6e5a124f;hb=2143d3737553b293923ad566ef4cda3aec742f75;hp=c9788211cd187f0520c026970dac89ec432c2300;hpb=c02b4fc9db3c3c1e263027382697b566127f66bb;p=coreboot.git diff --git a/src/devices/device.c b/src/devices/device.c index c9788211c..0e9c39e20 100644 --- a/src/devices/device.c +++ b/src/devices/device.c @@ -18,15 +18,18 @@ /* * (c) 1999--2000 Martin Mares */ -/* lots of mods by ron minnich (rminnich@lanl.gov), with - * the final architecture guidance from Tom Merritt (tjm@codegen.com) + +/* + * Lots of mods by Ron Minnich , with + * the final architecture guidance from Tom Merritt . + * * In particular, we changed from the one-pass original version to * Tom's recommended multiple-pass version. I wasn't sure about doing * it with multiple passes, until I actually started doing it and saw - * the wisdom of Tom's recommendations ... + * the wisdom of Tom's recommendations... * * Lots of cleanups by Eric Biederman to handle bridges, and to - * handle resource allocation for non-pci devices. + * handle resource allocation for non-PCI devices. */ #include @@ -38,80 +41,74 @@ #include #include #include +#if CONFIG_ARCH_X86 +#include +#endif /** Linked list of ALL devices */ struct device *all_devices = &dev_root; /** Pointer to the last device */ -extern struct device **last_dev_p; +extern struct device *last_dev; +/** Linked list of free resources */ +struct resource *free_resources = NULL; +DECLARE_SPIN_LOCK(dev_lock) /** - * @brief Allocate a new device structure. + * Allocate a new device structure. * - * Allocte a new device structure and attached it to the device tree as a + * Allocte a new device structure and attach it to the device tree as a * child of the parent bus. * - * @param parent parent bus the newly created device attached to. - * @param path path to the device to be created. - * - * @return pointer to the newly created device structure. + * @param parent Parent bus the newly created device should be attached to. + * @param path Path to the device to be created. + * @return Pointer to the newly created device structure. * * @see device_path */ - -DECLARE_SPIN_LOCK(dev_lock) - device_t alloc_dev(struct bus *parent, struct device_path *path) { device_t dev, child; - int link; spin_lock(&dev_lock); /* Find the last child of our parent. */ - for (child = parent->children; child && child->sibling; /* */ ) { + for (child = parent->children; child && child->sibling; /* */ ) child = child->sibling; - } dev = malloc(sizeof(*dev)); if (dev == 0) - die("DEV: out of memory.\n"); + die("alloc_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; - dev->link[link].link = link; - } - /* By default devices are enabled. */ dev->enabled = 1; /* Add the new device to the list of children of the bus. */ dev->bus = parent; - if (child) { + if (child) child->sibling = dev; - } else { + else parent->children = dev; - } /* Append a new device to the global device list. * The list is used to find devices once everything is set up. */ - *last_dev_p = dev; - last_dev_p = &dev->next; + last_dev->next = dev; + last_dev = dev; spin_unlock(&dev_lock); return dev; } /** - * @brief round a number up to an alignment. - * @param val the starting value - * @param roundup Alignment as a power of two - * @returns rounded up number + * Round a number up to an alignment. + * + * @param val The starting value. + * @param roundup Alignment as a power of two. + * @return Rounded up number. */ static resource_t round(resource_t val, unsigned long pow) { @@ -122,35 +119,38 @@ static resource_t round(resource_t val, unsigned long pow) return val; } -/** Read the resources on all devices of a given bus. - * @param bus bus to read the resources on. +/** + * Read the resources on all devices of a given bus. + * + * @param bus Bus to read the resources on. */ static void read_resources(struct bus *bus) { struct device *curdev; - printk(BIOS_SPEW, "%s %s bus %x link: %d\n", dev_path(bus->dev), __func__, - bus->secondary, bus->link); + printk(BIOS_SPEW, "%s %s bus %x link: %d\n", dev_path(bus->dev), + __func__, bus->secondary, bus->link_num); /* Walk through all devices and find which resources they need. */ for (curdev = bus->children; curdev; curdev = curdev->sibling) { - int i; - if (!curdev->enabled) { + struct bus *link; + + if (!curdev->enabled) continue; - } + if (!curdev->ops || !curdev->ops->read_resources) { printk(BIOS_ERR, "%s missing read_resources\n", - dev_path(curdev)); + dev_path(curdev)); continue; } curdev->ops->read_resources(curdev); /* Read in the resources behind the current device's links. */ - for (i = 0; i < curdev->links; i++) - read_resources(&curdev->link[i]); + for (link = curdev->link_list; link; link = link->next) + read_resources(link); } printk(BIOS_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_num); } struct pick_largest_state { @@ -174,7 +174,7 @@ static void pick_largest_resource(void *gp, struct device *dev, return; } if (resource->flags & IORESOURCE_FIXED) - return; // Skip it. + return; /* Skip it. */ if (last && ((last->align < resource->align) || ((last->align == resource->align) && (last->size < resource->size)) || @@ -210,7 +210,8 @@ static struct device *largest_resource(struct bus *bus, return state.result_dev; } -/* Compute allocate resources is the guts of the resource allocator. +/** + * This function is the guts of the resource allocator. * * The problem. * - Allocate resource locations for every device. @@ -236,46 +237,61 @@ static struct device *largest_resource(struct bus *bus, * 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. * + * @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. + * @return TODO */ static void compute_resources(struct bus *bus, struct resource *bridge, - unsigned long type_mask, unsigned long type) + unsigned long type_mask, unsigned long type) { struct device *dev; struct resource *resource; resource_t base; base = round(bridge->base, bridge->align); - printk(BIOS_SPEW, "%s %s_%s: base: %llx size: %llx align: %d gran: %d limit: %llx\n", - dev_path(bus->dev), __func__, + printk(BIOS_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); + "prefmem" : "mem", base, bridge->size, bridge->align, + bridge->gran, bridge->limit); - /* For each child which is a bridge, compute_resource_needs. */ + /* For each child which is a bridge, compute the resource needs. */ for (dev = bus->children; dev; dev = dev->sibling) { - unsigned i; struct resource *child_bridge; - if (!dev->links) + if (!dev->link_list) continue; /* Find the resources with matching type flags. */ - for (i = 0; i < dev->resources; i++) { - unsigned link; - child_bridge = &dev->resource[i]; + for (child_bridge = dev->resource_list; child_bridge; + child_bridge = child_bridge->next) { + struct bus* link; - if (!(child_bridge->flags & IORESOURCE_BRIDGE) || - (child_bridge->flags & type_mask) != type) + if (!(child_bridge->flags & IORESOURCE_BRIDGE) + || (child_bridge->flags & type_mask) != type) continue; - /* Split prefetchable memory if combined. Many domains + /* + * 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. + * 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, + link = dev->link_list; + while (link && link->link_num != + IOINDEX_LINK(child_bridge->index)) + link = link->next; + + if (link == NULL) { + printk(BIOS_ERR, "link %ld not found on %s\n", + IOINDEX_LINK(child_bridge->index), + dev_path(dev)); + } + + compute_resources(link, child_bridge, type_mask | IORESOURCE_PREFETCH, type | (child_bridge->flags & IORESOURCE_PREFETCH)); @@ -285,37 +301,37 @@ static void compute_resources(struct bus *bus, struct resource *bridge, /* 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 + /* + * 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))) { /* Size 0 resources can be skipped. */ - if (!resource->size) { + if (!resource->size) continue; - } /* Propagate the resource alignment to the bridge resource. */ - if (resource->align > bridge->align) { + if (resource->align > bridge->align) bridge->align = resource->align; - } /* Propagate the resource limit to the bridge register. */ - if (bridge->limit > resource->limit) { + if (bridge->limit > resource->limit) bridge->limit = resource->limit; - } /* Warn if it looks like APICs aren't declared. */ if ((resource->limit == 0xffffffff) && (resource->flags & IORESOURCE_ASSIGNED)) { - printk(BIOS_ERR, "Resource limit looks wrong! (no APIC?)\n"); - printk(BIOS_ERR, "%s %02lx limit %08Lx\n", dev_path(dev), - resource->index, resource->limit); + printk(BIOS_ERR, + "Resource limit looks wrong! (no APIC?)\n"); + printk(BIOS_ERR, "%s %02lx limit %08llx\n", + dev_path(dev), resource->index, resource->limit); } if (resource->flags & IORESOURCE_IO) { - /* Don't allow potential aliases over the legacy PCI + /* + * 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 @@ -324,7 +340,8 @@ static void compute_resources(struct bus *bus, struct resource *bridge, if ((base & 0x300) != 0) { base = (base & ~0x3ff) + 0x400; } - /* Don't allow allocations in the VGA I/O range. + /* + * Don't allow allocations in the VGA I/O range. * PCI has special cases for that. */ else if ((base >= 0x3b0) && (base <= 0x3df)) { @@ -337,73 +354,53 @@ static void compute_resources(struct bus *bus, struct resource *bridge, base += resource->size; printk(BIOS_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"); + 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. - * Round the size up to that minimum granularity so we - * know not to place something else at an address postitively - * decoded by the bridge. + + /* + * 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 postitively decoded by the bridge. */ bridge->size = round(base, bridge->gran) - round(bridge->base, bridge->align); - printk(BIOS_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); + printk(BIOS_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. + * See the compute_resources function for a more detailed explanation. * - * - 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. + * 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. + * @param type_mask This value gets ANDed with the resource type. + * @param type This value must match the result of the AND. + * + * @see compute_resources */ static void allocate_resources(struct bus *bus, struct resource *bridge, - unsigned long type_mask, unsigned long type) + unsigned long type_mask, unsigned long type) { struct device *dev; struct resource *resource; resource_t base; base = bridge->base; - printk(BIOS_SPEW, "%s %s_%s: base:%llx size:%llx align:%d gran:%d limit:%llx\n", - dev_path(bus->dev), __func__, + printk(BIOS_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); @@ -411,15 +408,15 @@ static void allocate_resources(struct bus *bus, struct resource *bridge, /* Remember we haven't found anything yet. */ resource = NULL; - /* Walk through all the resources on the current bus and allocate them + /* + * 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) { + if (resource->limit > bridge->limit) resource->limit = bridge->limit; - } /* Size 0 resources can be skipped. */ if (!resource->size) { @@ -430,7 +427,8 @@ static void allocate_resources(struct bus *bus, struct resource *bridge, } if (resource->flags & IORESOURCE_IO) { - /* Don't allow potential aliases over the legacy PCI + /* + * 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 @@ -439,7 +437,8 @@ static void allocate_resources(struct bus *bus, struct resource *bridge, if ((base & 0x300) != 0) { base = (base & ~0x3ff) + 0x400; } - /* Don't allow allocations in the VGA I/O range. + /* + * Don't allow allocations in the VGA I/O range. * PCI has special cases for that. */ else if ((base >= 0x3b0) && (base <= 0x3df)) { @@ -457,36 +456,33 @@ static void allocate_resources(struct bus *bus, struct resource *bridge, base += resource->size; } else { printk(BIOS_ERR, "!! Resource didn't fit !!\n"); - printk(BIOS_ERR, " aligned base %llx size %llx limit %llx\n", - round(base, resource->align), resource->size, - resource->limit); - printk(BIOS_ERR, " %llx needs to be <= %llx (limit)\n", - (round(base, resource->align) + + printk(BIOS_ERR, " aligned base %llx size %llx " + "limit %llx\n", round(base, resource->align), + resource->size, resource->limit); + printk(BIOS_ERR, " %llx needs to be <= %llx " + "(limit)\n", (round(base, resource->align) + resource->size) - 1, resource->limit); - printk(BIOS_ERR, " %s%s %02lx * [0x%llx - 0x%llx] %s\n", - (resource-> - flags & IORESOURCE_ASSIGNED) ? "Assigned: " : - "", dev_path(dev), resource->index, - resource->base, + printk(BIOS_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) + (resource->flags & IORESOURCE_IO) ? "io" + : (resource->flags & IORESOURCE_PREFETCH) ? "prefmem" : "mem"); } printk(BIOS_SPEW, "%s%s %02lx * [0x%llx - 0x%llx] %s\n", (resource->flags & IORESOURCE_ASSIGNED) ? "Assigned: " - : "", - dev_path(dev), resource->index, resource->base, + : "", 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"); + 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 + + /* + * 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. @@ -494,37 +490,45 @@ static void allocate_resources(struct bus *bus, struct resource *bridge, bridge->flags |= IORESOURCE_ASSIGNED; - printk(BIOS_SPEW, "%s %s_%s: next_base: %llx size: %llx align: %d gran: %d done\n", - dev_path(bus->dev), __func__, + printk(BIOS_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); + "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; - if (!dev->links) + if (!dev->link_list) continue; /* Find the resources with matching type flags. */ - for (i = 0; i < dev->resources; i++) { - unsigned link; - child_bridge = &dev->resource[i]; + for (child_bridge = dev->resource_list; child_bridge; + child_bridge = child_bridge->next) { + struct bus* link; if (!(child_bridge->flags & IORESOURCE_BRIDGE) || (child_bridge->flags & type_mask) != type) continue; - /* Split prefetchable memory if combined. Many domains + /* + * 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. + * 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, + link = dev->link_list; + while (link && link->link_num != + IOINDEX_LINK(child_bridge->index)) + link = link->next; + if (link == NULL) + printk(BIOS_ERR, "link %ld not found on %s\n", + IOINDEX_LINK(child_bridge->index), + dev_path(dev)); + + allocate_resources(link, child_bridge, type_mask | IORESOURCE_PREFETCH, type | (child_bridge->flags & IORESOURCE_PREFETCH)); @@ -533,14 +537,15 @@ static void allocate_resources(struct bus *bus, struct resource *bridge, } #if CONFIG_PCI_64BIT_PREF_MEM == 1 - #define MEM_MASK (IORESOURCE_PREFETCH | IORESOURCE_MEM) +#define MEM_MASK (IORESOURCE_PREFETCH | IORESOURCE_MEM) #else - #define MEM_MASK (IORESOURCE_MEM) +#define MEM_MASK (IORESOURCE_MEM) #endif -#define IO_MASK (IORESOURCE_IO) + +#define IO_MASK (IORESOURCE_IO) #define PREF_TYPE (IORESOURCE_PREFETCH | IORESOURCE_MEM) -#define MEM_TYPE (IORESOURCE_MEM) -#define IO_TYPE (IORESOURCE_IO) +#define MEM_TYPE (IORESOURCE_MEM) +#define IO_TYPE (IORESOURCE_IO) struct constraints { struct resource pref, io, mem; @@ -551,19 +556,18 @@ static void constrain_resources(struct device *dev, struct constraints* limits) struct device *child; struct resource *res; struct resource *lim; - int i; + struct bus *link; printk(BIOS_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]; + for (res = dev->resource_list; res; res = res->next) { if (!(res->flags & IORESOURCE_FIXED)) continue; if (!res->size) { /* It makes no sense to have 0-sized, fixed resources.*/ - printk(BIOS_ERR, "skipping %s@%lx fixed resource, size=0!\n", - dev_path(dev), res->index); + printk(BIOS_ERR, "skipping %s@%lx fixed resource, " + "size=0!\n", dev_path(dev), res->index); continue; } @@ -577,38 +581,44 @@ static void constrain_resources(struct device *dev, struct constraints* limits) else continue; - /* Is it already outside the limits? */ - if (((res->base + res->size -1) < lim->base) || (res->base > lim->limit)) + /* + * Is it a fixed resource outside the current known region? + * If so, we don't have to consider it - it will be handled + * correctly and doesn't affect current region's limits. + */ + if (((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. + /* + * 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)) + 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) + for (link = dev->link_list; link; link = link->next) { + for (child = link->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(BIOS_SPEW, "%s: %s\n", __func__, dev_path(dev)); - /* Initialize constraints to maximum size. */ + /* Initialize constraints to maximum size. */ limits.pref.base = 0; limits.pref.limit = 0xffffffffffffffffULL; limits.io.base = 0; @@ -617,12 +627,11 @@ static void avoid_fixed_resources(struct device *dev) limits.mem.limit = 0xffffffffffffffffULL; /* Constrain the limits to dev's initial resources. */ - for (i = 0; i < dev->resources; i++) { - res = &dev->resource[i]; + for (res = dev->resource_list; res; res = res->next) { if ((res->flags & IORESOURCE_FIXED)) continue; - printk(BIOS_SPEW, "%s:@%s %02lx limit %08Lx\n", __func__, - dev_path(dev), res->index, res->limit); + printk(BIOS_SPEW, "%s:@%s %02lx limit %08llx\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; @@ -638,9 +647,8 @@ static void avoid_fixed_resources(struct device *dev) constrain_resources(dev, &limits); /* Update dev's resources with new limits. */ - for (i = 0; i < dev->resources; i++) { + for (res = dev->resource_list; res; res = res->next) { struct resource *lim; - res = &dev->resource[i]; if ((res->flags & IORESOURCE_FIXED)) continue; @@ -655,9 +663,9 @@ static void avoid_fixed_resources(struct device *dev) else continue; - printk(BIOS_SPEW, "%s2: %s@%02lx limit %08Lx\n", __func__, + printk(BIOS_SPEW, "%s2: %s@%02lx limit %08llx\n", __func__, dev_path(dev), res->index, res->limit); - printk(BIOS_SPEW, "\tlim->base %08Lx lim->limit %08Lx\n", + printk(BIOS_SPEW, "\tlim->base %08llx lim->limit %08llx\n", lim->base, lim->limit); /* Is the resource outside the limits? */ @@ -673,7 +681,7 @@ device_t vga_pri = 0; static void set_vga_bridge_bits(void) { /* - * FIXME: Modify set_vga_bridge so it is less PCI centric! + * FIXME: Modify set_vga_bridge() so it is less PCI centric! * This function knows too much about PCI stuff, it should be just * an iterator/visitor. */ @@ -681,28 +689,30 @@ static void set_vga_bridge_bits(void) /* FIXME: Handle the VGA palette snooping. */ struct device *dev, *vga, *vga_onboard, *vga_first, *vga_last; struct bus *bus; + bus = 0; vga = 0; vga_onboard = 0; vga_first = 0; vga_last = 0; + 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) { + if (dev->on_mainboard) vga_onboard = dev; - } else { + else vga_first = dev; - } } else { - if (dev->on_mainboard) { + if (dev->on_mainboard) vga_onboard = dev; - } else { + else vga_last = dev; - } } /* It isn't safe to enable other VGA cards. */ @@ -712,30 +722,31 @@ static void set_vga_bridge_bits(void) vga = vga_last; - if (!vga) { + if (!vga) vga = vga_first; - } -#if CONFIG_CONSOLE_VGA_ONBOARD_AT_FIRST == 1 - if (vga_onboard) // Will use on board VGA as pri. + +#if CONFIG_ONBOARD_VGA_IS_PRIMARY == 1 + if (vga_onboard) /* Will use onboard VGA as primary. */ #else - if (!vga) // Will use last add on adapter as pri. + if (!vga) /* Will use last add-on adapter as primary. */ #endif { 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(BIOS_DEBUG, "Setting up VGA for %s\n", dev_path(vga)); /* 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) { printk(BIOS_DEBUG, "Setting PCI_BRIDGE_CTL_VGA for bridge %s\n", - dev_path(bus->dev)); + dev_path(bus->dev)); bus->bridge_ctrl |= PCI_BRIDGE_CTL_VGA; bus = (bus == bus->dev->bus) ? 0 : bus->dev->bus; } @@ -744,79 +755,73 @@ static void set_vga_bridge_bits(void) #endif /** - * @brief Assign the computed resources to the devices on the bus. + * Assign the computed resources to the devices on the bus. * - * @param bus Pointer to the structure for this bus - * - * Use the device specific set_resources method to store the computed + * Use the device specific set_resources() method to store the computed * resources to hardware. For bridge devices, the set_resources() method * has to recurse into every down stream buses. * * Mutual recursion: * assign_resources() -> device_operation::set_resources() * device_operation::set_resources() -> assign_resources() + * + * @param bus Pointer to the structure for this bus. */ void assign_resources(struct bus *bus) { struct device *curdev; printk(BIOS_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_num); for (curdev = bus->children; curdev; curdev = curdev->sibling) { - if (!curdev->enabled || !curdev->resources) { + if (!curdev->enabled || !curdev->resource_list) continue; - } + if (!curdev->ops || !curdev->ops->set_resources) { printk(BIOS_ERR, "%s missing set_resources\n", - dev_path(curdev)); + dev_path(curdev)); continue; } curdev->ops->set_resources(curdev); } printk(BIOS_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_num); } /** - * @brief Enable the resources for a specific device - * - * @param dev the device whose resources are to be enabled + * Enable the resources for devices on a link. * * Enable resources of the device by calling the device specific * enable_resources() method. * * The parent's resources should be enabled first to avoid having enabling * order problem. This is done by calling the parent's enable_resources() - * method and let that method to call it's children's enable_resoruces() - * method via the (global) enable_childrens_resources(). + * method before its childrens' enable_resources() methods. * - * Indirect mutual recursion: - * enable_resources() -> device_operations::enable_resource() - * device_operations::enable_resource() -> enable_children_resources() - * enable_children_resources() -> enable_resources() + * @param link The link whose devices' resources are to be enabled. */ -void enable_resources(struct device *dev) +static void enable_resources(struct bus *link) { - if (!dev->enabled) { - return; + struct device *dev; + struct bus *c_link; + + for (dev = link->children; dev; dev = dev->sibling) { + if (dev->enabled && dev->ops && dev->ops->enable_resources) + dev->ops->enable_resources(dev); } - if (!dev->ops || !dev->ops->enable_resources) { - printk(BIOS_ERR, "%s missing enable_resources\n", dev_path(dev)); - return; + + for (dev = link->children; dev; dev = dev->sibling) { + for (c_link = dev->link_list; c_link; c_link = c_link->next) + enable_resources(c_link); } - dev->ops->enable_resources(dev); } /** - * @brief Reset all of the devices a bus - * * Reset all of the devices on a bus and clear the bus's reset_needed flag. * - * @param bus pointer to the bus structure - * + * @param bus Pointer to the bus structure. * @return 1 if the bus was successfully reset, 0 otherwise. - * */ int reset_bus(struct bus *bus) { @@ -829,7 +834,7 @@ int reset_bus(struct bus *bus) } /** - * @brief Scan for devices on a bus. + * 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 @@ -843,6 +848,7 @@ unsigned int scan_bus(struct device *busdev, unsigned int max) { unsigned int new_max; int do_scan_bus; + if (!busdev || !busdev->enabled || !busdev->ops || !busdev->ops->scan_bus) { return max; @@ -850,16 +856,15 @@ unsigned int scan_bus(struct device *busdev, unsigned int max) do_scan_bus = 1; while (do_scan_bus) { - int link; + struct bus *link; new_max = busdev->ops->scan_bus(busdev, max); do_scan_bus = 0; - for (link = 0; link < busdev->links; link++) { - if (busdev->link[link].reset_needed) { - if (reset_bus(&busdev->link[link])) { + for (link = busdev->link_list; link; link = link->next) { + if (link->reset_needed) { + if (reset_bus(link)) do_scan_bus = 1; - } else { + else busdev->bus->reset_needed = 1; - } } } } @@ -867,21 +872,21 @@ unsigned int scan_bus(struct device *busdev, unsigned int max) } /** - * @brief Determine the existence of devices and extend the device tree. + * Determine the existence of devices and extend the device tree. * - * Most of the devices in the system are listed in the mainboard Config.lb + * Most of the devices in the system are listed in the mainboard devicetree.cb * file. The device structures for these devices are generated at compile * time by the config tool and are organized into the device tree. This * function determines if the devices created at compile time actually exist * in the physical system. * - * For devices in the physical system but not listed in the Config.lb file, + * For devices in the physical system but not listed in devicetree.cb, * the device structures have to be created at run time and attached to the * device tree. * - * This function starts from the root device 'dev_root', scan the buses in - * the system recursively, modify the device tree according to the result of - * the probe. + * This function starts from the root device 'dev_root', scans the buses in + * the system recursively, and modifies the device tree according to the + * result of the probe. * * This function has no idea how to scan and probe buses and devices at all. * It depends on the bus/device specific scan_bus() method to do it. The @@ -891,16 +896,18 @@ unsigned int scan_bus(struct device *busdev, unsigned int max) void dev_enumerate(void) { struct device *root; + printk(BIOS_INFO, "Enumerating buses...\n"); + root = &dev_root; - show_all_devs(BIOS_SPEW, "Before Device Enumeration."); + show_all_devs(BIOS_SPEW, "Before device enumeration."); printk(BIOS_SPEW, "Compare with tree...\n"); show_devs_tree(root, BIOS_SPEW, 0, 0); - if (root->chip_ops && root->chip_ops->enable_dev) { + if (root->chip_ops && root->chip_ops->enable_dev) root->chip_ops->enable_dev(root); - } + if (!root->ops || !root->ops->scan_bus) { printk(BIOS_ERR, "dev_root missing scan_bus operation"); return; @@ -910,7 +917,7 @@ void dev_enumerate(void) } /** - * @brief Configure devices on the devices tree. + * Configure devices on the devices tree. * * Starting at the root of the device tree, travel it recursively in two * passes. In the first pass, we compute and allocate resources (ranges) @@ -927,7 +934,6 @@ void dev_configure(void) struct resource *res; struct device *root; struct device *child; - int i; #if CONFIG_VGA_BRIDGE_SETUP == 1 set_vga_bridge_bits(); @@ -937,7 +943,8 @@ void dev_configure(void) root = &dev_root; - /* Each domain should create resources which contain the entire address + /* + * 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. */ @@ -945,50 +952,49 @@ void dev_configure(void) /* Read the resources for the entire tree. */ printk(BIOS_INFO, "Reading resources...\n"); - read_resources(&root->link[0]); + read_resources(root->link_list); printk(BIOS_INFO, "Done reading resources.\n"); print_resource_tree(root, BIOS_SPEW, "After reading."); /* Compute resources for all domains. */ - for (child = root->link[0].children; child; child = child->sibling) { + for (child = root->link_list->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]; + for (res = child->resource_list; res; res = res->next) { if (res->flags & IORESOURCE_FIXED) continue; if (res->flags & IORESOURCE_PREFETCH) { - compute_resources(&child->link[0], - res, MEM_MASK, PREF_TYPE); + compute_resources(child->link_list, + res, MEM_MASK, PREF_TYPE); continue; } if (res->flags & IORESOURCE_MEM) { - compute_resources(&child->link[0], - res, MEM_MASK, MEM_TYPE); + compute_resources(child->link_list, + res, MEM_MASK, MEM_TYPE); continue; } if (res->flags & IORESOURCE_IO) { - compute_resources(&child->link[0], - res, IO_MASK, IO_TYPE); + compute_resources(child->link_list, + res, IO_MASK, IO_TYPE); continue; } } } /* For all domains. */ - for (child = root->link[0].children; child; child=child->sibling) + for (child = root->link_list->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 + /* + * Now we need to adjust the resources. MEM resources need to start at * the highest address managable. */ - for (child = root->link[0].children; child; child = child->sibling) { + for (child = root->link_list->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]; + for (res = child->resource_list; res; res = res->next) { if (!(res->flags & IORESOURCE_MEM) || res->flags & IORESOURCE_FIXED) continue; @@ -998,31 +1004,30 @@ void dev_configure(void) /* Store the computed resource allocations into device registers ... */ printk(BIOS_INFO, "Setting resources...\n"); - for (child = root->link[0].children; child; child = child->sibling) { + for (child = root->link_list->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]; + for (res = child->resource_list; res; res = res->next) { if (res->flags & IORESOURCE_FIXED) continue; if (res->flags & IORESOURCE_PREFETCH) { - allocate_resources(&child->link[0], - res, MEM_MASK, PREF_TYPE); + allocate_resources(child->link_list, + res, MEM_MASK, PREF_TYPE); continue; } if (res->flags & IORESOURCE_MEM) { - allocate_resources(&child->link[0], - res, MEM_MASK, MEM_TYPE); + allocate_resources(child->link_list, + res, MEM_MASK, MEM_TYPE); continue; } if (res->flags & IORESOURCE_IO) { - allocate_resources(&child->link[0], - res, IO_MASK, IO_TYPE); + allocate_resources(child->link_list, + res, IO_MASK, IO_TYPE); continue; } } } - assign_resources(&root->link[0]); + assign_resources(root->link_list); printk(BIOS_INFO, "Done setting resources.\n"); print_resource_tree(root, BIOS_SPEW, "After assigning values."); @@ -1030,46 +1035,88 @@ void dev_configure(void) } /** - * @brief Enable devices on the device tree. + * Enable devices on the device tree. * * Starting at the root, walk the tree and enable all devices/bridges by * calling the device's enable_resources() method. */ void dev_enable(void) { + struct bus *link; + printk(BIOS_INFO, "Enabling resources...\n"); - /* now enable everything. */ - enable_resources(&dev_root); + /* Now enable everything. */ + for (link = dev_root.link_list; link; link = link->next) + enable_resources(link); printk(BIOS_INFO, "done.\n"); } /** - * @brief Initialize all devices in the global device list. + * Initialize a specific device. + * + * The parent should be initialized first to avoid having an ordering problem. + * This is done by calling the parent's init() method before its childrens' + * init() methods. * - * Starting at the first device on the global device link list, - * walk the list and call the device's init() method to do deivce - * specific setup. + * @param dev The device to be initialized. */ -void dev_initialize(void) +static void init_dev(struct device *dev) { - struct device *dev; + if (!dev->enabled) + return; - printk(BIOS_INFO, "Initializing devices...\n"); - for (dev = all_devices; dev; dev = dev->next) { - if (dev->enabled && !dev->initialized && - dev->ops && dev->ops->init) { - if (dev->path.type == DEVICE_PATH_I2C) { - printk(BIOS_DEBUG, "smbus: %s[%d]->", - dev_path(dev->bus->dev), - dev->bus->link); - } - printk(BIOS_DEBUG, "%s init\n", dev_path(dev)); - dev->initialized = 1; - dev->ops->init(dev); + if (!dev->initialized && dev->ops && dev->ops->init) { + if (dev->path.type == DEVICE_PATH_I2C) { + printk(BIOS_DEBUG, "smbus: %s[%d]->", + dev_path(dev->bus->dev), dev->bus->link_num); } + + printk(BIOS_DEBUG, "%s init\n", dev_path(dev)); + dev->initialized = 1; + dev->ops->init(dev); } +} + +static void init_link(struct bus *link) +{ + struct device *dev; + struct bus *c_link; + + for (dev = link->children; dev; dev = dev->sibling) + init_dev(dev); + + for (dev = link->children; dev; dev = dev->sibling) { + for (c_link = dev->link_list; c_link; c_link = c_link->next) + init_link(c_link); + } +} + +/** + * Initialize all devices in the global device tree. + * + * Starting at the root device, call the device's init() method to do + * device-specific setup, then call each child's init() method. + */ +void dev_initialize(void) +{ + struct bus *link; + + printk(BIOS_INFO, "Initializing devices...\n"); + +#if CONFIG_ARCH_X86 + /* Ensure EBDA is prepared before Option ROMs. */ + setup_default_ebda(); +#endif + + /* First call the mainboard init. */ + init_dev(&dev_root); + + /* Now initialize everything. */ + for (link = dev_root.link_list; link; link = link->next) + init_link(link); + printk(BIOS_INFO, "Devices initialized\n"); show_all_devs(BIOS_SPEW, "After init."); }