From e9a271e32c53076445ef70da8aec8201c82693ec Mon Sep 17 00:00:00 2001 From: Eric Biederman Date: Tue, 2 Sep 2003 03:36:25 +0000 Subject: - Major update of the dynamic device tree so it can handle * subtractive resources * merging with the static device tree * more device types than just pci - The piece to watch out for is the new enable_resources method that was needed in all of the drivers git-svn-id: svn://svn.coreboot.org/coreboot/trunk@1096 2b7e53f0-3cfb-0310-b3e9-8179ed1497e1 --- src/devices/device.c | 246 +++++++++++++++++++++++++++++++++------------------ 1 file changed, 159 insertions(+), 87 deletions(-) (limited to 'src/devices/device.c') diff --git a/src/devices/device.c b/src/devices/device.c index 8e6fcb3519..e52cc2a57e 100644 --- a/src/devices/device.c +++ b/src/devices/device.c @@ -1,6 +1,7 @@ /* * (c) 1999--2000 Martin Mares * (c) 2003 Eric Biederman + * (c) 2003 Linux Networx */ /* lots of mods by ron minnich (rminnich@lanl.gov), with * the final architecture guidance from Tom Merritt (tjm@codegen.com) @@ -18,12 +19,9 @@ #include #include #include +#include +#include -/** - * This is the root of the device tree. A PCI tree always has - * one bus, bus 0. Bus 0 contains devices and bridges. - */ -struct device dev_root; /* Linked list of ALL devices */ struct device *all_devices = 0; /* pointer to the last device */ @@ -32,16 +30,46 @@ static struct device **last_dev_p = &all_devices; #define DEVICE_MEM_HIGH 0xFEC00000UL /* Reserve 20M for the system */ #define DEVICE_IO_START 0x1000 - -/* Append a new device to the global device chain. - * The chain is used to find devices once everything is set up. +/** Allocate a new device structure */ -void append_device(struct device *dev) +device_t alloc_dev(struct bus *parent, struct device_path *path) { + device_t dev, child; + int link; + /* Find the last child of our parent */ + for(child = parent->children; child && child->sibling; ) { + child = child->sibling; + } + dev = malloc(sizeof(*dev)); + if (dev == 0) { + die("DEV: out of memory.\n"); + } + memset(dev, 0, sizeof(*dev)); + memcpy(&dev->path, path, sizeof(*path)); + + /* Append a new device to the global device chain. + * The chain is used to find devices once everything is set up. + */ *last_dev_p = dev; last_dev_p = &dev->next; -} + /* 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; + } + + /* Add the new device to the children of the bus. */ + dev->bus = parent; + if (child) { + child->sibling = dev; + } else { + parent->children = dev; + } + /* If we don't have any other information about a device enable it */ + dev->enable = 1; + return dev; +} /** round a number to an alignment. * @param val the starting value @@ -71,28 +99,79 @@ static unsigned long round_down(unsigned long val, unsigned long round_down) /** Read the resources on all devices of a given bus. * @param bus bus to read the resources on. */ -static void read_resources(struct device *bus) +static void read_resources(struct bus *bus) { struct device *curdev; - /* Walk through all of the devices and find which resources they need. */ for(curdev = bus->children; curdev; curdev = curdev->sibling) { + unsigned links; + int i; if (curdev->resources > 0) { continue; } + if (!curdev->ops || !curdev->ops->read_resources) { + printk_err("%s missing read_resources\n", + dev_path(curdev)); + continue; + } curdev->ops->read_resources(curdev); + /* Read in subtractive resources behind the current device */ + links = 0; + for(i = 0; i < curdev->resources; i++) { + struct resource *resource; + resource = &curdev->resource[i]; + if ((resource->flags & IORESOURCE_SUBTRACTIVE) && + (!(links & (1 << resource->index)))) + { + links |= (1 << resource->index); + read_resources(&curdev->link[resource->index]); + + } + } } } -static struct device *largest_resource(struct device *bus, struct resource **result_res, - unsigned long type_mask, unsigned long type) +struct pick_largest_state { + struct resource *last; + struct device *result_dev; + struct resource *result; + int seen_last; +}; + +static void pick_largest_resource( + struct pick_largest_state *state, struct device *dev, struct resource *resource) +{ + struct resource *last; + last = state->last; + /* Be certain to pick the successor to last */ + if (resource == last) { + state->seen_last = 1; + return; + } + if (last && ( + (last->align < resource->align) || + ((last->align == resource->align) && + (last->size < resource->size)) || + ((last->align == resource->align) && + (last->size == resource->size) && + (!state->seen_last)))) { + return; + } + if (!state->result || + (state->result->align < resource->align) || + ((state->result->align == resource->align) && + (state->result->size < resource->size))) { + state->result_dev = dev; + state->result = resource; + } + +} + +static void find_largest_resource(struct pick_largest_state *state, + struct bus *bus, unsigned long type_mask, unsigned long type) { struct device *curdev; - struct device *result_dev = 0; - struct resource *last = *result_res; - struct resource *result = 0; - int seen_last = 0; for(curdev = bus->children; curdev; curdev = curdev->sibling) { int i; for(i = 0; i < curdev->resources; i++) { @@ -101,31 +180,33 @@ static struct device *largest_resource(struct device *bus, struct resource **res if ((resource->flags & type_mask) != type) { continue; } - /* Be certain to pick the successor to last */ - if (resource == last) { - seen_last = 1; + /* If it is a subtractive resource recurse */ + if (resource->flags & IORESOURCE_SUBTRACTIVE) { + struct bus *subbus; + subbus = &curdev->link[resource->index]; + find_largest_resource(state, subbus, type_mask, type); continue; } - if (last && ( - (last->align < resource->align) || - ((last->align == resource->align) && - (last->size < resource->size)) || - ((last->align == resource->align) && - (last->size == resource->size) && - (!seen_last)))) { - continue; - } - if (!result || - (result->align < resource->align) || - ((result->align == resource->align) && - (result->size < resource->size))) { - result_dev = curdev; - result = resource; - } + /* See if this is the largest resource */ + pick_largest_resource(state, curdev, resource); } } - *result_res = result; - return result_dev; +} + +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.seen_last = 0; + + find_largest_resource(&state, bus, type_mask, type); + + *result_res = state.result; + return state.result_dev; } /* Compute allocate resources is the guts of the resource allocator. @@ -158,7 +239,7 @@ static struct device *largest_resource(struct device *bus, struct resource **res */ void compute_allocate_resource( - struct device *bus, + struct bus *bus, struct resource *bridge, unsigned long type_mask, unsigned long type) @@ -181,9 +262,8 @@ void compute_allocate_resource( min_align = log2(DEVICE_MEM_ALIGN); } - printk_spew("DEV: %02x:%02x.%01x compute_allocate_%s: base: %08lx size: %08lx align: %d gran: %d\n", - bus->bus->secondary, - PCI_SLOT(bus->devfn), PCI_FUNC(bus->devfn), + printk_spew("%s compute_allocate_%s: base: %08lx size: %08lx align: %d gran: %d\n", + dev_path(dev), (bridge->flags & IORESOURCE_IO)? "io": (bridge->flags & IORESOURCE_PREFETCH)? "prefmem" : "mem", base, bridge->size, bridge->align, bridge->gran); @@ -214,6 +294,9 @@ void compute_allocate_resource( if (align < min_align) { align = min_align; } + if (resource->flags & IORESOURCE_FIXED) { + continue; + } if (resource->flags & IORESOURCE_IO) { /* Don't allow potential aliases over the * legacy pci expansion card addresses. @@ -240,9 +323,8 @@ void compute_allocate_resource( base += size; printk_spew( - "DEV: %02x:%02x.%01x %02x * [0x%08lx - 0x%08lx] %s\n", - dev->bus->secondary, - PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn), + "%s %02x * [0x%08lx - 0x%08lx] %s\n", + dev_path(dev), resource->index, resource->base, resource->base + resource->size -1, (resource->flags & IORESOURCE_IO)? "io": @@ -258,9 +340,8 @@ void compute_allocate_resource( */ bridge->size = round(base, 1UL << bridge->gran) - bridge->base; - printk_spew("DEV: %02x:%02x.%01x compute_allocate_%s: base: %08lx size: %08lx align: %d gran: %d done\n", - bus->bus->secondary, - PCI_SLOT(bus->devfn), PCI_FUNC(bus->devfn), + printk_spew("%s compute_allocate_%s: base: %08lx size: %08lx align: %d gran: %d done\n", + dev_path(dev), (bridge->flags & IORESOURCE_IO)? "io": (bridge->flags & IORESOURCE_PREFETCH)? "prefmem" : "mem", base, bridge->size, bridge->align, bridge->gran); @@ -270,14 +351,15 @@ void compute_allocate_resource( static void allocate_vga_resource(void) { +#warning "FIXME modify allocate_vga_resource so it is less pci centric!" /* FIXME handle the VGA pallette snooping */ - struct device *dev, *vga, *bus; - bus = vga = 0; + struct device *dev, *vga; + struct bus *bus; + bus = 0; + vga = 0; for(dev = all_devices; dev; dev = dev->next) { - uint32_t class_revision; - class_revision = pci_read_config32(dev, PCI_CLASS_REVISION); - if (((class_revision >> 24) == 0x03) && - ((class_revision >> 16) != 0x380)) { + if (((dev->class >> 16) == 0x03) && + ((dev->class >> 8) != 0x380)) { if (!vga) { printk_debug("Allocating VGA resource\n"); vga = dev; @@ -296,11 +378,8 @@ static void allocate_vga_resource(void) } /* Now walk up the bridges setting the VGA enable */ while(bus) { - uint16_t ctrl; - ctrl = pci_read_config16(bus, PCI_BRIDGE_CONTROL); - ctrl |= PCI_BRIDGE_CTL_VGA; - pci_write_config16(bus, PCI_BRIDGE_CONTROL, ctrl); - bus = (bus == bus->bus)? 0 : bus->bus; + bus->bridge_ctrl |= PCI_BRIDGE_CONTROL; + bus = (bus == bus->dev->bus)? 0 : bus->dev->bus; } } @@ -310,36 +389,35 @@ static void allocate_vga_resource(void) * on this bus. * @param bus Pointer to the structure for this bus */ -void assign_resources(struct device *bus) +void assign_resources(struct bus *bus) { struct device *curdev; printk_debug("ASSIGN RESOURCES, bus %d\n", bus->secondary); for (curdev = bus->children; curdev; curdev = curdev->sibling) { + if (!curdev->ops || !curdev->ops->set_resources) { + printk_err("%s missing set_resources\n", + dev_path(curdev)); + continue; + } curdev->ops->set_resources(curdev); } printk_debug("ASSIGNED RESOURCES, bus %d\n", bus->secondary); } -static void enable_resources(struct device *bus) +void enable_resources(struct device *dev) { - struct device *curdev; - - /* Walk through the chain of all pci devices and enable them. - * This is effectively a breadth first traversal so we should - * not have enalbing ordering problems. + /* Enable the resources for a specific device. + * The parents resources should be enabled first to avoid + * having enabling ordering problems. */ - for (curdev = all_devices; curdev; curdev = curdev->next) { - uint16_t command; - command = pci_read_config16(curdev, PCI_COMMAND); - command |= curdev->command; - printk_debug("DEV: %02x:%02x.%01x cmd <- %02x\n", - curdev->bus->secondary, - PCI_SLOT(curdev->devfn), PCI_FUNC(curdev->devfn), - command); - pci_write_config16(curdev, PCI_COMMAND, command); + if (!dev->ops || !dev->ops->enable_resources) { + printk_err("%s missing enable_resources\n", + dev_path(dev)); + return; } + dev->ops->enable_resources(dev); } /** Enumerate the resources on the PCI by calling pci_init @@ -347,12 +425,10 @@ static void enable_resources(struct device *bus) void dev_enumerate(void) { struct device *root; + unsigned subordinate; printk_info("Enumerating buses..."); root = &dev_root; - if (!root->ops) { - root->ops = &default_pci_ops_root; - } - root->subordinate = root->ops->scan_bus(root, 0); + subordinate = root->ops->scan_bus(root, 0); printk_info("done\n"); } @@ -394,7 +470,7 @@ void dev_configure(void) */ void dev_enable(void) { - printk_info("Enabling resourcess..."); + printk_info("Enabling resourcess...\n"); /* now enable everything. */ enable_resources(&dev_root); @@ -410,14 +486,10 @@ void dev_initialize(void) printk_info("Initializing devices...\n"); for (dev = all_devices; dev; dev = dev->next) { - if (dev->ops->init) { - printk_debug("PCI: %02x:%02x.%01x init\n", - dev->bus->secondary, - PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn)); + if (dev->ops && dev->ops->init) { + printk_debug("%s init\n", dev_path(dev)); dev->ops->init(dev); } } printk_info("Devices initialized\n"); } - - -- cgit v1.2.3