2 * This file is part of the coreboot project.
4 * It was originally based on the Linux kernel (arch/i386/kernel/pci-pc.c).
7 * Copyright (C) 2003 Eric Biederman <ebiederm@xmission.com>
8 * Copyright (C) 2003-2004 Linux Networx
9 * (Written by Eric Biederman <ebiederman@lnxi.com> for Linux Networx)
10 * Copyright (C) 2003 Ronald G. Minnich <rminnich@gmail.com>
11 * Copyright (C) 2004-2005 Li-Ta Lo <ollie@lanl.gov>
12 * Copyright (C) 2005-2006 Tyan
13 * (Written by Yinghai Lu <yhlu@tyan.com> for Tyan)
14 * Copyright (C) 2005-2006 Stefan Reinauer <stepan@openbios.org>
18 * (c) 1999--2000 Martin Mares <mj@suse.cz>
20 /* lots of mods by ron minnich (rminnich@lanl.gov), with
21 * the final architecture guidance from Tom Merritt (tjm@codegen.com)
22 * In particular, we changed from the one-pass original version to
23 * Tom's recommended multiple-pass version. I wasn't sure about doing
24 * it with multiple passes, until I actually started doing it and saw
25 * the wisdom of Tom's recommendations ...
27 * Lots of cleanups by Eric Biederman to handle bridges, and to
28 * handle resource allocation for non-pci devices.
31 #include <console/console.h>
34 #include <device/device.h>
35 #include <device/pci.h>
36 #include <device/pci_ids.h>
39 #include <smp/spinlock.h>
41 /** Linked list of ALL devices */
42 struct device *all_devices = &dev_root;
43 /** Pointer to the last device */
44 extern struct device **last_dev_p;
46 /** The upper limit of MEM resource of the devices.
47 * Reserve 20M for the system */
48 #define DEVICE_MEM_HIGH 0xFEBFFFFFUL
49 /** The lower limit of IO resource of the devices.
50 * Reserve 4k for ISA/Legacy devices */
51 #define DEVICE_IO_START 0x1000
54 * @brief Allocate a new device structure.
56 * Allocte a new device structure and attached it to the device tree as a
57 * child of the parent bus.
59 * @param parent parent bus the newly created device attached to.
60 * @param path path to the device to be created.
62 * @return pointer to the newly created device structure.
66 static spinlock_t dev_lock = SPIN_LOCK_UNLOCKED;
67 device_t alloc_dev(struct bus *parent, struct device_path *path)
74 /* Find the last child of our parent */
75 for(child = parent->children; child && child->sibling; ) {
76 child = child->sibling;
79 dev = malloc(sizeof(*dev));
81 die("DEV: out of memory.\n");
83 memset(dev, 0, sizeof(*dev));
84 memcpy(&dev->path, path, sizeof(*path));
86 /* Initialize the back pointers in the link fields */
87 for(link = 0; link < MAX_LINKS; link++) {
88 dev->link[link].dev = dev;
89 dev->link[link].link = link;
92 /* By default devices are enabled */
95 /* Add the new device to the list of children of the bus. */
100 parent->children = dev;
103 /* Append a new device to the global device list.
104 * The list is used to find devices once everything is set up.
107 last_dev_p = &dev->next;
109 spin_unlock(&dev_lock);
114 * @brief round a number up to an alignment.
115 * @param val the starting value
116 * @param roundup Alignment as a power of two
117 * @returns rounded up number
119 static resource_t round(resource_t val, unsigned long pow)
122 mask = (1ULL << pow) - 1ULL;
128 /** Read the resources on all devices of a given bus.
129 * @param bus bus to read the resources on.
131 static void read_resources(struct bus *bus)
133 struct device *curdev;
135 printk_spew("%s read_resources bus %d link: %d\n",
136 dev_path(bus->dev), bus->secondary, bus->link);
138 /* Walk through all of the devices and find which resources they need. */
139 for(curdev = bus->children; curdev; curdev = curdev->sibling) {
142 if (curdev->have_resources) {
145 if (!curdev->enabled) {
148 if (!curdev->ops || !curdev->ops->read_resources) {
149 printk_err("%s missing read_resources\n",
153 curdev->ops->read_resources(curdev);
154 curdev->have_resources = 1;
155 /* Read in subtractive resources behind the current device */
157 for(i = 0; i < curdev->resources; i++) {
158 struct resource *resource;
160 resource = &curdev->resource[i];
161 if (!(resource->flags & IORESOURCE_SUBTRACTIVE))
163 link = IOINDEX_SUBTRACTIVE_LINK(resource->index);
164 if (link > MAX_LINKS) {
165 printk_err("%s subtractive index on link: %d\n",
166 dev_path(curdev), link);
169 if (!(links & (1 << link))) {
170 links |= (1 << link);
171 read_resources(&curdev->link[link]);
175 printk_spew("%s read_resources bus %d link: %d done\n",
176 dev_path(bus->dev), bus->secondary, bus->link);
179 struct pick_largest_state {
180 struct resource *last;
181 struct device *result_dev;
182 struct resource *result;
186 static void pick_largest_resource(void *gp,
187 struct device *dev, struct resource *resource)
189 struct pick_largest_state *state = gp;
190 struct resource *last;
192 /* Be certain to pick the successor to last */
193 if (resource == last) {
194 state->seen_last = 1;
197 if (resource->flags & IORESOURCE_FIXED ) return; //skip it
199 (last->align < resource->align) ||
200 ((last->align == resource->align) &&
201 (last->size < resource->size)) ||
202 ((last->align == resource->align) &&
203 (last->size == resource->size) &&
204 (!state->seen_last)))) {
207 if (!state->result ||
208 (state->result->align < resource->align) ||
209 ((state->result->align == resource->align) &&
210 (state->result->size < resource->size)))
212 state->result_dev = dev;
213 state->result = resource;
217 static struct device *largest_resource(struct bus *bus, struct resource **result_res,
218 unsigned long type_mask, unsigned long type)
220 struct pick_largest_state state;
222 state.last = *result_res;
223 state.result_dev = 0;
227 search_bus_resources(bus, type_mask, type, pick_largest_resource, &state);
229 *result_res = state.result;
230 return state.result_dev;
233 /* Compute allocate resources is the guts of the resource allocator.
236 * - Allocate resources locations for every device.
237 * - Don't overlap, and follow the rules of bridges.
238 * - Don't overlap with resources in fixed locations.
239 * - Be efficient so we don't have ugly strategies.
242 * - Devices that have fixed addresses are the minority so don't
243 * worry about them too much. Instead only use part of the address
244 * space for devices with programmable addresses. This easily handles
245 * everything except bridges.
247 * - PCI devices are required to have thier sizes and their alignments
248 * equal. In this case an optimal solution to the packing problem
249 * exists. Allocate all devices from highest alignment to least
250 * alignment or vice versa. Use this.
252 * - So we can handle more than PCI run two allocation passes on
253 * bridges. The first to see how large the resources are behind
254 * the bridge, and what their alignment requirements are. The
255 * second to assign a safe address to the devices behind the
256 * bridge. This allows me to treat a bridge as just a device with
257 * a couple of resources, and not need to special case it in the
258 * allocator. Also this allows handling of other types of bridges.
262 void compute_allocate_resource(
264 struct resource *bridge,
265 unsigned long type_mask,
269 struct resource *resource;
271 unsigned long align, min_align;
275 printk_spew("%s compute_allocate_resource %s: base: %08Lx size: %08Lx align: %d gran: %d\n",
277 (bridge->flags & IORESOURCE_IO)? "io":
278 (bridge->flags & IORESOURCE_PREFETCH)? "prefmem" : "mem",
279 base, bridge->size, bridge->align, bridge->gran);
281 /* We want different minimum alignments for different kinds of
282 * resources. These minimums are not device type specific
283 * but resource type specific.
285 if (bridge->flags & IORESOURCE_IO) {
286 min_align = log2(DEVICE_IO_ALIGN);
288 if (bridge->flags & IORESOURCE_MEM) {
289 min_align = log2(DEVICE_MEM_ALIGN);
292 /* Make certain I have read in all of the resources */
295 /* Remember I haven't found anything yet. */
298 /* Walk through all the devices on the current bus and
299 * compute the addresses.
301 while((dev = largest_resource(bus, &resource, type_mask, type))) {
303 /* Do NOT I repeat do not ignore resources which have zero size.
304 * If they need to be ignored dev->read_resources should not even
305 * return them. Some resources must be set even when they have
306 * no size. PCI bridge resources are a good example of this.
308 /* Make certain we are dealing with a good minimum size */
309 size = resource->size;
310 align = resource->align;
311 if (align < min_align) {
315 /* Propagate the resource alignment to the bridge register */
316 if (align > bridge->align) {
317 bridge->align = align;
320 if (resource->flags & IORESOURCE_FIXED) {
324 /* Propogate the resource limit to the bridge register */
325 if (bridge->limit > resource->limit) {
326 bridge->limit = resource->limit;
328 #warning This heuristics should be replaced by real devices with fixed resources.
329 /* Artificially deny limits between DEVICE_MEM_HIGH and 0xffffffff */
330 if ((bridge->limit > DEVICE_MEM_HIGH) && (bridge->limit <= 0xffffffff)) {
331 bridge->limit = DEVICE_MEM_HIGH;
334 if (resource->flags & IORESOURCE_IO) {
335 /* Don't allow potential aliases over the
336 * legacy pci expansion card addresses.
337 * The legacy pci decodes only 10 bits,
338 * uses 100h - 3ffh. Therefor, only 0 - ff
339 * can be used out of each 400h block of io
342 if ((base & 0x300) != 0) {
343 base = (base & ~0x3ff) + 0x400;
345 /* Don't allow allocations in the VGA IO range.
346 * PCI has special cases for that.
348 else if ((base >= 0x3b0) && (base <= 0x3df)) {
352 if (((round(base, align) + size) -1) <= resource->limit) {
353 /* base must be aligned to size */
354 base = round(base, align);
355 resource->base = base;
356 resource->flags |= IORESOURCE_ASSIGNED;
357 resource->flags &= ~IORESOURCE_STORED;
361 "%s %02x * [0x%08Lx - 0x%08Lx] %s\n",
365 resource->base + resource->size - 1,
366 (resource->flags & IORESOURCE_IO)? "io":
367 (resource->flags & IORESOURCE_PREFETCH)? "prefmem": "mem");
370 /* A pci bridge resource does not need to be a power
371 * of two size, but it does have a minimum granularity.
372 * Round the size up to that minimum granularity so we
373 * know not to place something else at an address postitively
374 * decoded by the bridge.
376 bridge->size = round(base, bridge->gran) - bridge->base;
378 printk_spew("%s compute_allocate_resource %s: base: %08Lx size: %08Lx align: %d gran: %d done\n",
380 (bridge->flags & IORESOURCE_IO)? "io":
381 (bridge->flags & IORESOURCE_PREFETCH)? "prefmem" : "mem",
382 base, bridge->size, bridge->align, bridge->gran);
387 #if CONFIG_CONSOLE_VGA == 1
388 device_t vga_pri = 0;
389 static void allocate_vga_resource(void)
391 #warning "FIXME modify allocate_vga_resource so it is less pci centric!"
392 #warning "This function knows to much about PCI stuff, it should be just a ietrator/visitor."
394 /* FIXME handle the VGA pallette snooping */
395 struct device *dev, *vga, *vga_onboard, *vga_first, *vga_last;
402 for(dev = all_devices; dev; dev = dev->next) {
403 if (!dev->enabled) continue;
404 if (((dev->class >> 16) == PCI_BASE_CLASS_DISPLAY) &&
405 ((dev->class >> 8) != PCI_CLASS_DISPLAY_OTHER))
408 if (dev->on_mainboard) {
414 if (dev->on_mainboard) {
421 /* It isn't safe to enable other VGA cards */
422 dev->command &= ~(PCI_COMMAND_MEMORY | PCI_COMMAND_IO);
432 #if CONFIG_CONSOLE_VGA_ONBOARD_AT_FIRST == 1
433 if (vga_onboard) // will use on board vga as pri
435 if (!vga) // will use last add on adapter as pri
443 /* vga is first add on card or the only onboard vga */
444 printk_debug("Allocating VGA resource %s\n", dev_path(vga));
445 /* All legacy VGA cards have MEM & I/O space registers */
446 vga->command |= (PCI_COMMAND_MEMORY | PCI_COMMAND_IO);
450 /* Now walk up the bridges setting the VGA enable */
452 printk_debug("Setting PCI_BRIDGE_CTL_VGA for bridge %s\n",
454 bus->bridge_ctrl |= PCI_BRIDGE_CTL_VGA;
455 bus = (bus == bus->dev->bus)? 0 : bus->dev->bus;
463 * @brief Assign the computed resources to the devices on the bus.
465 * @param bus Pointer to the structure for this bus
467 * Use the device specific set_resources method to store the computed
468 * resources to hardware. For bridge devices, the set_resources() method
469 * has to recurse into every down stream buses.
472 * assign_resources() -> device_operation::set_resources()
473 * device_operation::set_resources() -> assign_resources()
475 void assign_resources(struct bus *bus)
477 struct device *curdev;
479 printk_spew("%s assign_resources, bus %d link: %d\n",
480 dev_path(bus->dev), bus->secondary, bus->link);
482 for(curdev = bus->children; curdev; curdev = curdev->sibling) {
483 if (!curdev->enabled || !curdev->resources) {
486 if (!curdev->ops || !curdev->ops->set_resources) {
487 printk_err("%s missing set_resources\n",
491 curdev->ops->set_resources(curdev);
493 printk_spew("%s assign_resources, bus %d link: %d\n",
494 dev_path(bus->dev), bus->secondary, bus->link);
498 * @brief Enable the resources for a specific device
500 * @param dev the device whose resources are to be enabled
502 * Enable resources of the device by calling the device specific
503 * enable_resources() method.
505 * The parent's resources should be enabled first to avoid having enabling
506 * order problem. This is done by calling the parent's enable_resources()
507 * method and let that method to call it's children's enable_resoruces()
508 * method via the (global) enable_childrens_resources().
510 * Indirect mutual recursion:
511 * enable_resources() -> device_operations::enable_resource()
512 * device_operations::enable_resource() -> enable_children_resources()
513 * enable_children_resources() -> enable_resources()
515 void enable_resources(struct device *dev)
520 if (!dev->ops || !dev->ops->enable_resources) {
521 printk_err("%s missing enable_resources\n", dev_path(dev));
524 dev->ops->enable_resources(dev);
528 * @brief Reset all of the devices a bus
530 * Reset all of the devices on a bus and clear the bus's reset_needed flag.
532 * @param bus pointer to the bus structure
534 * @return 1 if the bus was successfully reset, 0 otherwise.
537 int reset_bus(struct bus *bus)
539 if (bus && bus->dev && bus->dev->ops && bus->dev->ops->reset_bus)
541 bus->dev->ops->reset_bus(bus);
542 bus->reset_needed = 0;
549 * @brief Scan for devices on a bus.
551 * If there are bridges on the bus, recursively scan the buses behind the bridges.
552 * If the setting up and tuning of the bus causes a reset to be required,
553 * reset the bus and scan it again.
555 * @param bus pointer to the bus device
556 * @param max current bus number
558 * @return The maximum bus number found, after scanning all subordinate busses
560 unsigned int scan_bus(device_t bus, unsigned int max)
562 unsigned int new_max;
574 new_max = bus->ops->scan_bus(bus, max);
576 for(link = 0; link < bus->links; link++) {
577 if (bus->link[link].reset_needed) {
578 if (reset_bus(&bus->link[link])) {
581 bus->bus->reset_needed = 1;
591 * @brief Determine the existence of devices and extend the device tree.
593 * Most of the devices in the system are listed in the mainboard Config.lb
594 * file. The device structures for these devices are generated at compile
595 * time by the config tool and are organized into the device tree. This
596 * function determines if the devices created at compile time actually exist
597 * in the physical system.
599 * For devices in the physical system but not listed in the Config.lb file,
600 * the device structures have to be created at run time and attached to the
603 * This function starts from the root device 'dev_root', scan the buses in
604 * the system recursively, modify the device tree according to the result of
607 * This function has no idea how to scan and probe buses and devices at all.
608 * It depends on the bus/device specific scan_bus() method to do it. The
609 * scan_bus() method also has to create the device structure and attach
610 * it to the device tree.
612 void dev_enumerate(void)
615 unsigned subordinate;
616 printk_info("Enumerating buses...\n");
618 if (root->chip_ops && root->chip_ops->enable_dev) {
619 root->chip_ops->enable_dev(root);
621 if (!root->ops || !root->ops->scan_bus) {
622 printk_err("dev_root missing scan_bus operation");
625 subordinate = scan_bus(root, 0);
626 printk_info("done\n");
630 * @brief Configure devices on the devices tree.
632 * Starting at the root of the device tree, travel it recursively in two
633 * passes. In the first pass, we compute and allocate resources (ranges)
634 * requried by each device. In the second pass, the resources ranges are
635 * relocated to their final position and stored to the hardware.
637 * I/O resources start at DEVICE_IO_START and grow upward. MEM resources start
638 * at DEVICE_MEM_HIGH and grow downward.
640 * Since the assignment is hierarchical we set the values into the dev_root
643 void dev_configure(void)
645 struct resource *io, *mem;
648 printk_info("Allocating resources...\n");
651 if (!root->ops || !root->ops->read_resources) {
652 printk_err("dev_root missing read_resources\n");
655 if (!root->ops || !root->ops->set_resources) {
656 printk_err("dev_root missing set_resources\n");
660 printk_info("Reading resources...\n");
661 root->ops->read_resources(root);
662 printk_info("Done reading resources.\n");
664 /* Get the resources */
665 io = &root->resource[0];
666 mem = &root->resource[1];
667 /* Make certain the io devices are allocated somewhere safe. */
668 io->base = DEVICE_IO_START;
669 io->flags |= IORESOURCE_ASSIGNED;
670 io->flags &= ~IORESOURCE_STORED;
671 /* Now reallocate the pci resources memory with the
672 * highest addresses I can manage.
674 mem->base = resource_max(&root->resource[1]);
675 mem->flags |= IORESOURCE_ASSIGNED;
676 mem->flags &= ~IORESOURCE_STORED;
678 #if CONFIG_CONSOLE_VGA == 1
679 /* Allocate the VGA I/O resource.. */
680 allocate_vga_resource();
683 /* Store the computed resource allocations into device registers ... */
684 printk_info("Setting resources...\n");
685 root->ops->set_resources(root);
686 printk_info("Done setting resources.\n");
688 mem->flags |= IORESOURCE_STORED;
689 report_resource_stored(root, mem, "");
692 printk_info("Done allocating resources.\n");
696 * @brief Enable devices on the device tree.
698 * Starting at the root, walk the tree and enable all devices/bridges by
699 * calling the device's enable_resources() method.
701 void dev_enable(void)
703 printk_info("Enabling resources...\n");
705 /* now enable everything. */
706 enable_resources(&dev_root);
708 printk_info("done.\n");
712 * @brief Initialize all devices in the global device list.
714 * Starting at the first device on the global device link list,
715 * walk the list and call the device's init() method to do deivce
718 void dev_initialize(void)
722 printk_info("Initializing devices...\n");
723 for(dev = all_devices; dev; dev = dev->next) {
724 if (dev->enabled && !dev->initialized &&
725 dev->ops && dev->ops->init)
727 if (dev->path.type == DEVICE_PATH_I2C) {
728 printk_debug("smbus: %s[%d]->",
729 dev_path(dev->bus->dev), dev->bus->link);
731 printk_debug("%s init\n", dev_path(dev));
732 dev->initialized = 1;
736 printk_info("Devices initialized\n");